Mercurial > libavcodec.hg
annotate h264.c @ 4594:a96d905dcbaa libavcodec
Add av_ prefix to clip functions
author | reimar |
---|---|
date | Sun, 25 Feb 2007 10:27:12 +0000 |
parents | 9fc8acda3223 |
children | 6ac364a4ce2b |
rev | line source |
---|---|
1168 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1168 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1168 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1168 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3029
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1168 | 20 * |
21 */ | |
2967 | 22 |
1168 | 23 /** |
24 * @file h264.c | |
25 * H.264 / AVC / MPEG4 part10 codec. | |
26 * @author Michael Niedermayer <michaelni@gmx.at> | |
27 */ | |
28 | |
29 #include "common.h" | |
30 #include "dsputil.h" | |
31 #include "avcodec.h" | |
32 #include "mpegvideo.h" | |
33 #include "h264data.h" | |
34 #include "golomb.h" | |
35 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
36 #include "cabac.h" |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
37 |
3284
a224d9752912
don't force asserts in release builds. 2% faster h264.
lorenm
parents:
3219
diff
changeset
|
38 //#undef NDEBUG |
1168 | 39 #include <assert.h> |
40 | |
41 #define interlaced_dct interlaced_dct_is_a_bad_name | |
42 #define mb_intra mb_intra_isnt_initalized_see_mb_type | |
43 | |
44 #define LUMA_DC_BLOCK_INDEX 25 | |
45 #define CHROMA_DC_BLOCK_INDEX 26 | |
46 | |
47 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
48 #define COEFF_TOKEN_VLC_BITS 8 | |
49 #define TOTAL_ZEROS_VLC_BITS 9 | |
50 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
51 #define RUN_VLC_BITS 3 | |
52 #define RUN7_VLC_BITS 6 | |
53 | |
54 #define MAX_SPS_COUNT 32 | |
55 #define MAX_PPS_COUNT 256 | |
56 | |
57 #define MAX_MMCO_COUNT 66 | |
58 | |
3316 | 59 /* Compiling in interlaced support reduces the speed |
60 * of progressive decoding by about 2%. */ | |
61 #define ALLOW_INTERLACE | |
62 | |
63 #ifdef ALLOW_INTERLACE | |
64 #define MB_MBAFF h->mb_mbaff | |
65 #define MB_FIELD h->mb_field_decoding_flag | |
66 #define FRAME_MBAFF h->mb_aff_frame | |
67 #else | |
68 #define MB_MBAFF 0 | |
69 #define MB_FIELD 0 | |
70 #define FRAME_MBAFF 0 | |
71 #undef IS_INTERLACED | |
72 #define IS_INTERLACED(mb_type) 0 | |
73 #endif | |
74 | |
1168 | 75 /** |
76 * Sequence parameter set | |
77 */ | |
78 typedef struct SPS{ | |
2967 | 79 |
1168 | 80 int profile_idc; |
81 int level_idc; | |
2763 | 82 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag |
1168 | 83 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 |
84 int poc_type; ///< pic_order_cnt_type | |
85 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
86 int delta_pic_order_always_zero_flag; | |
87 int offset_for_non_ref_pic; | |
88 int offset_for_top_to_bottom_field; | |
89 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
90 int ref_frame_count; ///< num_ref_frames | |
1371 | 91 int gaps_in_frame_num_allowed_flag; |
1168 | 92 int mb_width; ///< frame_width_in_mbs_minus1 + 1 |
93 int mb_height; ///< frame_height_in_mbs_minus1 + 1 | |
94 int frame_mbs_only_flag; | |
95 int mb_aff; ///<mb_adaptive_frame_field_flag | |
96 int direct_8x8_inference_flag; | |
1371 | 97 int crop; ///< frame_cropping_flag |
98 int crop_left; ///< frame_cropping_rect_left_offset | |
99 int crop_right; ///< frame_cropping_rect_right_offset | |
100 int crop_top; ///< frame_cropping_rect_top_offset | |
101 int crop_bottom; ///< frame_cropping_rect_bottom_offset | |
1168 | 102 int vui_parameters_present_flag; |
1548 | 103 AVRational sar; |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
104 int timing_info_present_flag; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
105 uint32_t num_units_in_tick; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
106 uint32_t time_scale; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
107 int fixed_frame_rate_flag; |
1168 | 108 short offset_for_ref_frame[256]; //FIXME dyn aloc? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
109 int bitstream_restriction_flag; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
110 int num_reorder_frames; |
2919 | 111 int scaling_matrix_present; |
112 uint8_t scaling_matrix4[6][16]; | |
113 uint8_t scaling_matrix8[2][64]; | |
1168 | 114 }SPS; |
115 | |
116 /** | |
117 * Picture parameter set | |
118 */ | |
119 typedef struct PPS{ | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
120 unsigned int sps_id; |
1168 | 121 int cabac; ///< entropy_coding_mode_flag |
122 int pic_order_present; ///< pic_order_present_flag | |
123 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
124 int mb_slice_group_map_type; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
125 unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 |
1168 | 126 int weighted_pred; ///< weighted_pred_flag |
127 int weighted_bipred_idc; | |
128 int init_qp; ///< pic_init_qp_minus26 + 26 | |
129 int init_qs; ///< pic_init_qs_minus26 + 26 | |
130 int chroma_qp_index_offset; | |
131 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag | |
132 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
133 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
2755 | 134 int transform_8x8_mode; ///< transform_8x8_mode_flag |
2919 | 135 uint8_t scaling_matrix4[6][16]; |
136 uint8_t scaling_matrix8[2][64]; | |
1168 | 137 }PPS; |
138 | |
139 /** | |
140 * Memory management control operation opcode. | |
141 */ | |
142 typedef enum MMCOOpcode{ | |
143 MMCO_END=0, | |
144 MMCO_SHORT2UNUSED, | |
145 MMCO_LONG2UNUSED, | |
146 MMCO_SHORT2LONG, | |
147 MMCO_SET_MAX_LONG, | |
2967 | 148 MMCO_RESET, |
1168 | 149 MMCO_LONG, |
150 } MMCOOpcode; | |
151 | |
152 /** | |
153 * Memory management control operation. | |
154 */ | |
155 typedef struct MMCO{ | |
156 MMCOOpcode opcode; | |
157 int short_frame_num; | |
158 int long_index; | |
159 } MMCO; | |
160 | |
161 /** | |
162 * H264Context | |
163 */ | |
164 typedef struct H264Context{ | |
165 MpegEncContext s; | |
2967 | 166 int nal_ref_idc; |
1168 | 167 int nal_unit_type; |
168 uint8_t *rbsp_buffer; | |
3066
04b924f8f5a5
warning fixes by Luca Abeni, lucabe72 ##@## email ##.## it
diego
parents:
3063
diff
changeset
|
169 unsigned int rbsp_buffer_size; |
1168 | 170 |
2227 | 171 /** |
172 * Used to parse AVC variant of h264 | |
173 */ | |
174 int is_avc; ///< this flag is != 0 if codec is avc1 | |
175 int got_avcC; ///< flag used to parse avcC data only once | |
176 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
177 | |
1168 | 178 int chroma_qp; //QPc |
179 | |
3316 | 180 int prev_mb_skipped; |
181 int next_mb_skipped; | |
1168 | 182 |
183 //prediction stuff | |
184 int chroma_pred_mode; | |
185 int intra16x16_pred_mode; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
186 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
187 int top_mb_xy; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
188 int left_mb_xy[2]; |
2967 | 189 |
1168 | 190 int8_t intra4x4_pred_mode_cache[5*8]; |
191 int8_t (*intra4x4_pred_mode)[8]; | |
192 void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp? | |
2755 | 193 void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride); |
1168 | 194 void (*pred8x8 [4+3])(uint8_t *src, int stride); |
195 void (*pred16x16[4+3])(uint8_t *src, int stride); | |
196 unsigned int topleft_samples_available; | |
197 unsigned int top_samples_available; | |
198 unsigned int topright_samples_available; | |
199 unsigned int left_samples_available; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
200 uint8_t (*top_borders[2])[16+2*8]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
201 uint8_t left_border[2*(17+2*9)]; |
1168 | 202 |
203 /** | |
204 * non zero coeff count cache. | |
205 * is 64 if not available. | |
206 */ | |
3089 | 207 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
208 uint8_t (*non_zero_count)[16]; |
1168 | 209 |
210 /** | |
211 * Motion vector cache. | |
212 */ | |
3089 | 213 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); |
214 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); | |
1168 | 215 #define LIST_NOT_USED -1 //FIXME rename? |
216 #define PART_NOT_AVAILABLE -2 | |
2967 | 217 |
1168 | 218 /** |
219 * is 1 if the specific list MV&references are set to 0,0,-2. | |
220 */ | |
221 int mv_cache_clean[2]; | |
222 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
223 /** |
2755 | 224 * number of neighbors (top and/or left) that used 8x8 dct |
225 */ | |
226 int neighbor_transform_size; | |
227 | |
228 /** | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
229 * block_offset[ 0..23] for frame macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
230 * block_offset[24..47] for field macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
231 */ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
232 int block_offset[2*(16+8)]; |
2967 | 233 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
234 uint32_t *mb2b_xy; //FIXME are these 4 a good idea? |
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
235 uint32_t *mb2b8_xy; |
2395 | 236 int b_stride; //FIXME use s->b4_stride |
1168 | 237 int b8_stride; |
238 | |
3316 | 239 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff |
240 int mb_uvlinesize; | |
241 | |
242 int emu_edge_width; | |
243 int emu_edge_height; | |
244 | |
1234 | 245 int halfpel_flag; |
246 int thirdpel_flag; | |
247 | |
1319 | 248 int unknown_svq3_flag; |
249 int next_slice_index; | |
250 | |
1168 | 251 SPS sps_buffer[MAX_SPS_COUNT]; |
252 SPS sps; ///< current sps | |
2967 | 253 |
1168 | 254 PPS pps_buffer[MAX_PPS_COUNT]; |
255 /** | |
256 * current pps | |
257 */ | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
258 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? |
1168 | 259 |
2919 | 260 uint32_t dequant4_buffer[6][52][16]; |
261 uint32_t dequant8_buffer[2][52][64]; | |
262 uint32_t (*dequant4_coeff[6])[16]; | |
263 uint32_t (*dequant8_coeff[2])[64]; | |
264 int dequant_coeff_pps; ///< reinit tables when pps changes | |
2755 | 265 |
1168 | 266 int slice_num; |
267 uint8_t *slice_table_base; | |
3316 | 268 uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
1168 | 269 int slice_type; |
270 int slice_type_fixed; | |
2967 | 271 |
1168 | 272 //interlacing specific flags |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
273 int mb_aff_frame; |
1168 | 274 int mb_field_decoding_flag; |
3316 | 275 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag |
2967 | 276 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
277 unsigned int sub_mb_type[4]; |
2967 | 278 |
1168 | 279 //POC stuff |
280 int poc_lsb; | |
281 int poc_msb; | |
282 int delta_poc_bottom; | |
283 int delta_poc[2]; | |
284 int frame_num; | |
285 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
286 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
287 int frame_num_offset; ///< for POC type 2 | |
288 int prev_frame_num_offset; ///< for POC type 2 | |
289 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
290 | |
291 /** | |
292 * frame_num for frames or 2*frame_num for field pics. | |
293 */ | |
294 int curr_pic_num; | |
2967 | 295 |
1168 | 296 /** |
297 * max_frame_num or 2*max_frame_num for field pics. | |
298 */ | |
299 int max_pic_num; | |
300 | |
301 //Weighted pred stuff | |
2415 | 302 int use_weight; |
303 int use_weight_chroma; | |
1168 | 304 int luma_log2_weight_denom; |
305 int chroma_log2_weight_denom; | |
3316 | 306 int luma_weight[2][48]; |
307 int luma_offset[2][48]; | |
308 int chroma_weight[2][48][2]; | |
309 int chroma_offset[2][48][2]; | |
310 int implicit_weight[48][48]; | |
2967 | 311 |
1168 | 312 //deblock |
2967 | 313 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
314 int slice_alpha_c0_offset; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
315 int slice_beta_offset; |
2967 | 316 |
1168 | 317 int redundant_pic_count; |
2967 | 318 |
1168 | 319 int direct_spatial_mv_pred; |
2396 | 320 int dist_scale_factor[16]; |
3316 | 321 int dist_scale_factor_field[32]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
322 int map_col_to_list0[2][16]; |
3316 | 323 int map_col_to_list0_field[2][32]; |
1168 | 324 |
325 /** | |
326 * num_ref_idx_l0/1_active_minus1 + 1 | |
327 */ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
328 unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
4532 | 329 unsigned int list_count; |
2582 | 330 Picture *short_ref[32]; |
331 Picture *long_ref[32]; | |
1168 | 332 Picture default_ref_list[2][32]; |
3316 | 333 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs |
4389 | 334 Picture *delayed_pic[18]; //FIXME size? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
335 Picture *delayed_output_pic; |
2967 | 336 |
1168 | 337 /** |
338 * memory management control operations buffer. | |
339 */ | |
340 MMCO mmco[MAX_MMCO_COUNT]; | |
341 int mmco_index; | |
2967 | 342 |
1168 | 343 int long_ref_count; ///< number of actual long term references |
344 int short_ref_count; ///< number of actual short term references | |
2967 | 345 |
1168 | 346 //data partitioning |
347 GetBitContext intra_gb; | |
348 GetBitContext inter_gb; | |
349 GetBitContext *intra_gb_ptr; | |
350 GetBitContext *inter_gb_ptr; | |
2967 | 351 |
3089 | 352 DECLARE_ALIGNED_8(DCTELEM, mb[16*24]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
353 DCTELEM mb_padding[256]; ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not to large or ensure that there is some unused stuff after mb |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
354 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
355 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
356 * Cabac |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
357 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
358 CABACContext cabac; |
2755 | 359 uint8_t cabac_state[460]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
360 int cabac_init_idc; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
361 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
362 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
363 uint16_t *cbp_table; |
3651 | 364 int cbp; |
2314 | 365 int top_cbp; |
366 int left_cbp; | |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
367 /* chroma_pred_mode for i4x4 or i16x16, else 0 */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
368 uint8_t *chroma_pred_mode_table; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
369 int last_qscale_diff; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
370 int16_t (*mvd_table[2])[2]; |
3089 | 371 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); |
2396 | 372 uint8_t *direct_table; |
373 uint8_t direct_cache[5*8]; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
374 |
2748
135aa7d0bd17
avoid one transpose (730->680 dezicycles on duron)
michael
parents:
2717
diff
changeset
|
375 uint8_t zigzag_scan[16]; |
3174 | 376 uint8_t zigzag_scan8x8[64]; |
377 uint8_t zigzag_scan8x8_cavlc[64]; | |
3316 | 378 uint8_t field_scan[16]; |
379 uint8_t field_scan8x8[64]; | |
380 uint8_t field_scan8x8_cavlc[64]; | |
2763 | 381 const uint8_t *zigzag_scan_q0; |
3174 | 382 const uint8_t *zigzag_scan8x8_q0; |
383 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
3316 | 384 const uint8_t *field_scan_q0; |
385 const uint8_t *field_scan8x8_q0; | |
386 const uint8_t *field_scan8x8_cavlc_q0; | |
2967 | 387 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
388 int x264_build; |
1168 | 389 }H264Context; |
390 | |
391 static VLC coeff_token_vlc[4]; | |
392 static VLC chroma_dc_coeff_token_vlc; | |
393 | |
394 static VLC total_zeros_vlc[15]; | |
395 static VLC chroma_dc_total_zeros_vlc[3]; | |
396 | |
397 static VLC run_vlc[6]; | |
398 static VLC run7_vlc; | |
399 | |
1234 | 400 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
401 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc); | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
402 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize); |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
403 static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize); |
1234 | 404 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
405 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 406 #ifdef WORDS_BIGENDIAN |
407 return (b&0xFFFF) + (a<<16); | |
408 #else | |
409 return (a&0xFFFF) + (b<<16); | |
410 #endif | |
411 } | |
412 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
413 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
414 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
415 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
416 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
417 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
418 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
419 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
420 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
421 |
1168 | 422 /** |
423 * fill a rectangle. | |
2392 | 424 * @param h height of the rectangle, should be a constant |
425 * @param w width of the rectangle, should be a constant | |
1168 | 426 * @param size the size of val (1 or 4), should be a constant |
427 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
428 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 429 uint8_t *p= (uint8_t*)vp; |
1168 | 430 assert(size==1 || size==4); |
3315 | 431 assert(w<=4); |
2967 | 432 |
1168 | 433 w *= size; |
434 stride *= size; | |
2967 | 435 |
2962 | 436 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 437 assert((stride&(w-1))==0); |
3315 | 438 if(w==2){ |
439 const uint16_t v= size==4 ? val : val*0x0101; | |
440 *(uint16_t*)(p + 0*stride)= v; | |
441 if(h==1) return; | |
442 *(uint16_t*)(p + 1*stride)= v; | |
443 if(h==2) return; | |
1168 | 444 *(uint16_t*)(p + 2*stride)= |
3315 | 445 *(uint16_t*)(p + 3*stride)= v; |
446 }else if(w==4){ | |
447 const uint32_t v= size==4 ? val : val*0x01010101; | |
448 *(uint32_t*)(p + 0*stride)= v; | |
449 if(h==1) return; | |
450 *(uint32_t*)(p + 1*stride)= v; | |
451 if(h==2) return; | |
1168 | 452 *(uint32_t*)(p + 2*stride)= |
3315 | 453 *(uint32_t*)(p + 3*stride)= v; |
454 }else if(w==8){ | |
455 //gcc can't optimize 64bit math on x86_32 | |
456 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
457 const uint64_t v= val*0x0100000001ULL; | |
458 *(uint64_t*)(p + 0*stride)= v; | |
459 if(h==1) return; | |
460 *(uint64_t*)(p + 1*stride)= v; | |
461 if(h==2) return; | |
1168 | 462 *(uint64_t*)(p + 2*stride)= |
3315 | 463 *(uint64_t*)(p + 3*stride)= v; |
464 }else if(w==16){ | |
465 const uint64_t v= val*0x0100000001ULL; | |
1168 | 466 *(uint64_t*)(p + 0+0*stride)= |
467 *(uint64_t*)(p + 8+0*stride)= | |
468 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 469 *(uint64_t*)(p + 8+1*stride)= v; |
470 if(h==2) return; | |
1168 | 471 *(uint64_t*)(p + 0+2*stride)= |
472 *(uint64_t*)(p + 8+2*stride)= | |
473 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 474 *(uint64_t*)(p + 8+3*stride)= v; |
475 #else | |
476 *(uint32_t*)(p + 0+0*stride)= | |
477 *(uint32_t*)(p + 4+0*stride)= val; | |
478 if(h==1) return; | |
479 *(uint32_t*)(p + 0+1*stride)= | |
480 *(uint32_t*)(p + 4+1*stride)= val; | |
481 if(h==2) return; | |
482 *(uint32_t*)(p + 0+2*stride)= | |
483 *(uint32_t*)(p + 4+2*stride)= | |
484 *(uint32_t*)(p + 0+3*stride)= | |
485 *(uint32_t*)(p + 4+3*stride)= val; | |
486 }else if(w==16){ | |
487 *(uint32_t*)(p + 0+0*stride)= | |
488 *(uint32_t*)(p + 4+0*stride)= | |
489 *(uint32_t*)(p + 8+0*stride)= | |
490 *(uint32_t*)(p +12+0*stride)= | |
491 *(uint32_t*)(p + 0+1*stride)= | |
492 *(uint32_t*)(p + 4+1*stride)= | |
493 *(uint32_t*)(p + 8+1*stride)= | |
494 *(uint32_t*)(p +12+1*stride)= val; | |
495 if(h==2) return; | |
496 *(uint32_t*)(p + 0+2*stride)= | |
497 *(uint32_t*)(p + 4+2*stride)= | |
498 *(uint32_t*)(p + 8+2*stride)= | |
499 *(uint32_t*)(p +12+2*stride)= | |
500 *(uint32_t*)(p + 0+3*stride)= | |
501 *(uint32_t*)(p + 4+3*stride)= | |
502 *(uint32_t*)(p + 8+3*stride)= | |
503 *(uint32_t*)(p +12+3*stride)= val; | |
504 #endif | |
1168 | 505 }else |
506 assert(0); | |
3315 | 507 assert(h==4); |
1168 | 508 } |
509 | |
3028 | 510 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 511 MpegEncContext * const s = &h->s; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
512 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 513 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
514 int topleft_type, top_type, topright_type, left_type[2]; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
515 int left_block[8]; |
1168 | 516 int i; |
517 | |
3482 | 518 //FIXME deblocking could skip the intra and nnz parts. |
519 if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[mb_xy-s->mb_stride]) && !FRAME_MBAFF) | |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
520 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
521 |
2967 | 522 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
523 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
524 top_xy = mb_xy - s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
525 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
526 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
527 left_xy[1] = left_xy[0] = mb_xy-1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
528 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
529 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
530 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
531 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
532 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
533 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
534 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
535 left_block[7]= 11; |
3316 | 536 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
537 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
538 const int top_pair_xy = pair_xy - s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
539 const int topleft_pair_xy = top_pair_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
540 const int topright_pair_xy = top_pair_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
541 const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
542 const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
543 const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
544 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
545 const int curr_mb_frame_flag = !IS_INTERLACED(mb_type); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
546 const int bottom = (s->mb_y & 1); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
547 tprintf("fill_caches: curr_mb_frame_flag:%d, left_mb_frame_flag:%d, topleft_mb_frame_flag:%d, top_mb_frame_flag:%d, topright_mb_frame_flag:%d\n", curr_mb_frame_flag, left_mb_frame_flag, topleft_mb_frame_flag, top_mb_frame_flag, topright_mb_frame_flag); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
548 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
549 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
550 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
551 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
552 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
553 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
554 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
555 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
556 : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
557 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
558 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
559 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
560 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
561 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
562 : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
563 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
564 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
565 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
566 if (left_mb_frame_flag != curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
567 left_xy[1] = left_xy[0] = pair_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
568 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
569 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
570 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
571 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
572 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
573 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
574 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
575 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
576 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
577 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
578 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
579 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
580 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
581 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
582 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
583 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
584 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
585 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
586 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
587 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
588 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
589 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
590 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
591 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
592 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
593 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
594 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
595 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
596 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
597 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
598 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
599 } |
1168 | 600 } |
601 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
602 h->top_mb_xy = top_xy; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
603 h->left_mb_xy[0] = left_xy[0]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
604 h->left_mb_xy[1] = left_xy[1]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
605 if(for_deblock){ |
3482 | 606 topleft_type = 0; |
607 topright_type = 0; | |
2449 | 608 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
609 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
610 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 611 |
612 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
613 int list; | |
614 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
615 for(i=0; i<16; i++) | |
616 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
4533 | 617 for(list=0; list<h->list_count; list++){ |
3316 | 618 if(USES_LIST(mb_type,list)){ |
619 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
620 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 621 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 622 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
623 dst[0] = src[0]; | |
624 dst[1] = src[1]; | |
625 dst[2] = src[2]; | |
626 dst[3] = src[3]; | |
627 } | |
628 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
629 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
630 ref += h->b8_stride; | |
631 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
632 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
633 }else{ | |
634 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
635 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
636 } | |
637 } | |
638 } | |
2449 | 639 }else{ |
640 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
641 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
642 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
643 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
644 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
645 } | |
1168 | 646 |
647 if(IS_INTRA(mb_type)){ | |
2967 | 648 h->topleft_samples_available= |
649 h->top_samples_available= | |
1168 | 650 h->left_samples_available= 0xFFFF; |
651 h->topright_samples_available= 0xEEEA; | |
652 | |
653 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
654 h->topleft_samples_available= 0xB3FF; | |
655 h->top_samples_available= 0x33FF; | |
656 h->topright_samples_available= 0x26EA; | |
657 } | |
658 for(i=0; i<2; i++){ | |
659 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
660 h->topleft_samples_available&= 0xDF5F; | |
661 h->left_samples_available&= 0x5F5F; | |
662 } | |
663 } | |
2967 | 664 |
1168 | 665 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
666 h->topleft_samples_available&= 0x7FFF; | |
2967 | 667 |
1168 | 668 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
669 h->topright_samples_available&= 0xFBFF; | |
2967 | 670 |
1168 | 671 if(IS_INTRA4x4(mb_type)){ |
672 if(IS_INTRA4x4(top_type)){ | |
673 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
674 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
675 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
676 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
677 }else{ | |
678 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
679 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
680 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
681 else{ |
1168 | 682 pred= 2; |
683 } | |
684 h->intra4x4_pred_mode_cache[4+8*0]= | |
685 h->intra4x4_pred_mode_cache[5+8*0]= | |
686 h->intra4x4_pred_mode_cache[6+8*0]= | |
687 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
688 } | |
689 for(i=0; i<2; i++){ | |
690 if(IS_INTRA4x4(left_type[i])){ | |
691 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
692 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
693 }else{ | |
694 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
695 if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
696 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
697 else{ |
1168 | 698 pred= 2; |
699 } | |
700 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
701 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
702 } | |
703 } | |
704 } | |
705 } | |
2967 | 706 |
707 | |
1168 | 708 /* |
2967 | 709 0 . T T. T T T T |
710 1 L . .L . . . . | |
711 2 L . .L . . . . | |
712 3 . T TL . . . . | |
713 4 L . .L . . . . | |
714 5 L . .. . . . . | |
1168 | 715 */ |
716 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
717 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
718 h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
719 h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
720 h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
721 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 722 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
723 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
724 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 725 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
726 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
727 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 728 |
1168 | 729 }else{ |
2967 | 730 h->non_zero_count_cache[4+8*0]= |
1168 | 731 h->non_zero_count_cache[5+8*0]= |
732 h->non_zero_count_cache[6+8*0]= | |
733 h->non_zero_count_cache[7+8*0]= | |
2967 | 734 |
1168 | 735 h->non_zero_count_cache[1+8*0]= |
736 h->non_zero_count_cache[2+8*0]= | |
2967 | 737 |
1168 | 738 h->non_zero_count_cache[1+8*3]= |
2314 | 739 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 740 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
741 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
742 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
743 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
744 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
745 h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
746 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
747 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
748 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
749 }else{ |
2967 | 750 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
751 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
752 h->non_zero_count_cache[0+8*1 + 8*i]= | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
753 h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
754 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
755 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
756 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
757 if( h->pps.cabac ) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
758 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
759 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
760 h->top_cbp = h->cbp_table[top_xy]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
761 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
762 h->top_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
763 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
764 h->top_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
765 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
766 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
767 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
768 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
769 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
770 h->left_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
771 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
772 h->left_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
773 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
774 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
775 h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
776 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
777 if (left_type[1]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
778 h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
779 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
780 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
781 |
1168 | 782 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
783 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 784 int list; |
4533 | 785 for(list=0; list<h->list_count; list++){ |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
786 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 787 /*if(!h->mv_cache_clean[list]){ |
788 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
789 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
790 h->mv_cache_clean[list]= 1; | |
791 }*/ | |
2396 | 792 continue; |
1168 | 793 } |
794 h->mv_cache_clean[list]= 0; | |
2967 | 795 |
3212 | 796 if(USES_LIST(top_type, list)){ |
1168 | 797 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
798 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
799 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
800 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
801 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
802 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
803 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
804 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
805 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
806 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
807 }else{ | |
2967 | 808 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
809 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
810 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 811 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
812 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
813 } | |
814 | |
4546 | 815 for(i=0; i<2; i++){ |
816 int cache_idx = scan8[0] - 1 + i*2*8; | |
817 if(USES_LIST(left_type[i], list)){ | |
818 const int b_xy= h->mb2b_xy[left_xy[i]] + 3; | |
819 const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1; | |
820 *(uint32_t*)h->mv_cache[list][cache_idx ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]]; | |
821 *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]]; | |
822 h->ref_cache[list][cache_idx ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)]; | |
823 h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)]; | |
824 }else{ | |
825 *(uint32_t*)h->mv_cache [list][cache_idx ]= | |
826 *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0; | |
827 h->ref_cache[list][cache_idx ]= | |
828 h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
829 } | |
1168 | 830 } |
831 | |
3519 | 832 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 833 continue; |
834 | |
3212 | 835 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
|
836 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
|
837 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
|
838 *(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
|
839 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
|
840 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
841 *(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
|
842 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
|
843 } |
2967 | 844 |
3212 | 845 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
|
846 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
|
847 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
|
848 *(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
|
849 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
|
850 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
851 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
852 h->ref_cache[list][scan8[0] + 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
|
853 } |
2967 | 854 |
3519 | 855 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 856 continue; |
2967 | 857 |
858 h->ref_cache[list][scan8[5 ]+1] = | |
859 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
860 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 861 h->ref_cache[list][scan8[4 ]] = |
1168 | 862 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
863 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
864 *(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
|
865 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 866 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
867 *(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
|
868 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
869 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
|
870 /* XXX beurk, Load mvd */ |
3212 | 871 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
|
872 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
|
873 *(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
|
874 *(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
|
875 *(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
|
876 *(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
|
877 }else{ |
2967 | 878 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
879 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
880 *(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
|
881 *(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
|
882 } |
3212 | 883 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
|
884 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
|
885 *(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
|
886 *(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
|
887 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
888 *(uint32_t*)h->mvd_cache [list][scan8[0] - 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
|
889 *(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
|
890 } |
3212 | 891 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
|
892 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
|
893 *(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
|
894 *(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
|
895 }else{ |
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 + 2*8]= |
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 + 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
|
898 } |
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[5 ]+1]= |
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[7 ]+1]= |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
901 *(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
|
902 *(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
|
903 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 904 |
905 if(h->slice_type == B_TYPE){ | |
906 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
907 | |
908 if(IS_DIRECT(top_type)){ | |
909 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
910 }else if(IS_8X8(top_type)){ | |
911 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
912 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
913 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
914 }else{ | |
915 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
916 } | |
2967 | 917 |
3316 | 918 if(IS_DIRECT(left_type[0])) |
919 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
920 else if(IS_8X8(left_type[0])) | |
921 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)]; | |
922 else | |
923 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
924 | |
925 if(IS_DIRECT(left_type[1])) | |
2396 | 926 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 927 else if(IS_8X8(left_type[1])) |
928 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)]; | |
929 else | |
2396 | 930 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 931 } |
932 } | |
933 | |
934 if(FRAME_MBAFF){ | |
935 #define MAP_MVS\ | |
936 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
937 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
938 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
939 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
940 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
941 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
942 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
943 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
944 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
945 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
946 if(MB_FIELD){ | |
947 #define MAP_F2F(idx, mb_type)\ | |
948 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
949 h->ref_cache[list][idx] <<= 1;\ | |
950 h->mv_cache[list][idx][1] /= 2;\ | |
951 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 952 } |
3316 | 953 MAP_MVS |
954 #undef MAP_F2F | |
955 }else{ | |
956 #define MAP_F2F(idx, mb_type)\ | |
957 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
958 h->ref_cache[list][idx] >>= 1;\ | |
959 h->mv_cache[list][idx][1] <<= 1;\ | |
960 h->mvd_cache[list][idx][1] <<= 1;\ | |
961 } | |
962 MAP_MVS | |
963 #undef MAP_F2F | |
2396 | 964 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
965 } |
1168 | 966 } |
967 } | |
968 #endif | |
2755 | 969 |
970 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 971 } |
972 | |
973 static inline void write_back_intra_pred_mode(H264Context *h){ | |
974 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
|
975 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 976 |
977 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
978 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
979 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
980 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
981 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
982 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
983 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
984 } | |
985 | |
986 /** | |
987 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
988 */ | |
989 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
990 MpegEncContext * const s = &h->s; | |
991 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
992 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
993 int i; | |
2967 | 994 |
1168 | 995 if(!(h->top_samples_available&0x8000)){ |
996 for(i=0; i<4; i++){ | |
997 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
998 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
999 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 | 1000 return -1; |
1001 } else if(status){ | |
1002 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
1003 } | |
1004 } | |
1005 } | |
2967 | 1006 |
1168 | 1007 if(!(h->left_samples_available&0x8000)){ |
1008 for(i=0; i<4; i++){ | |
1009 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
1010 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1011 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 | 1012 return -1; |
1013 } else if(status){ | |
1014 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
1015 } | |
1016 } | |
1017 } | |
1018 | |
1019 return 0; | |
1020 } //FIXME cleanup like next | |
1021 | |
1022 /** | |
1023 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1024 */ | |
1025 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
1026 MpegEncContext * const s = &h->s; | |
1027 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
1028 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 1029 |
4529 | 1030 if(mode > 6U) { |
2392 | 1031 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 | 1032 return -1; |
2392 | 1033 } |
2967 | 1034 |
1168 | 1035 if(!(h->top_samples_available&0x8000)){ |
1036 mode= top[ mode ]; | |
1037 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1038 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 | 1039 return -1; |
1040 } | |
1041 } | |
2967 | 1042 |
1168 | 1043 if(!(h->left_samples_available&0x8000)){ |
1044 mode= left[ mode ]; | |
1045 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1046 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 | 1047 return -1; |
2967 | 1048 } |
1168 | 1049 } |
1050 | |
1051 return mode; | |
1052 } | |
1053 | |
1054 /** | |
1055 * gets the predicted intra4x4 prediction mode. | |
1056 */ | |
1057 static inline int pred_intra_mode(H264Context *h, int n){ | |
1058 const int index8= scan8[n]; | |
1059 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1060 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1061 const int min= FFMIN(left, top); | |
1062 | |
1170 | 1063 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 1064 |
1065 if(min<0) return DC_PRED; | |
1066 else return min; | |
1067 } | |
1068 | |
1069 static inline void write_back_non_zero_count(H264Context *h){ | |
1070 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
|
1071 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
|
1072 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1073 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
|
1074 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
|
1075 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
|
1076 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
|
1077 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
|
1078 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
|
1079 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 1080 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1081 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
|
1082 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
|
1083 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
|
1084 |
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][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
|
1086 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
|
1087 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 1088 |
1089 if(FRAME_MBAFF){ | |
1090 // store all luma nnzs, for deblocking | |
1091 int v = 0, i; | |
1092 for(i=0; i<16; i++) | |
1093 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
1094 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
1095 } | |
1168 | 1096 } |
1097 | |
1098 /** | |
1099 * gets the predicted number of non zero coefficients. | |
1100 * @param n block index | |
1101 */ | |
1102 static inline int pred_non_zero_count(H264Context *h, int n){ | |
1103 const int index8= scan8[n]; | |
1104 const int left= h->non_zero_count_cache[index8 - 1]; | |
1105 const int top = h->non_zero_count_cache[index8 - 8]; | |
1106 int i= left + top; | |
2967 | 1107 |
1168 | 1108 if(i<64) i= (i+1)>>1; |
1109 | |
1170 | 1110 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 1111 |
1112 return i&31; | |
1113 } | |
1114 | |
1169 | 1115 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
1116 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
1117 | |
3316 | 1118 /* there is no consistent mapping of mvs to neighboring locations that will |
1119 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
1120 if(FRAME_MBAFF){ | |
1121 MpegEncContext *s = &h->s; | |
3776 | 1122 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 1123 const int16_t *mv; |
1124 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
1125 *C = h->mv_cache[list][scan8[0]-2]; | |
1126 | |
1127 if(!MB_FIELD | |
1128 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
1129 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
1130 if(IS_INTERLACED(mb_types[topright_xy])){ | |
1131 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
1132 const int x4 = X4, y4 = Y4;\ | |
1133 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
1134 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
1135 return LIST_NOT_USED;\ | |
1136 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
1137 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
1138 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
1139 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
1140 | |
1141 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
1142 } | |
1143 } | |
1144 if(topright_ref == PART_NOT_AVAILABLE | |
1145 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
1146 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
1147 if(!MB_FIELD | |
1148 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
1149 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
1150 } | |
1151 if(MB_FIELD | |
1152 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
1153 && i >= scan8[0]+8){ | |
1154 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
1155 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
1156 } | |
1157 } | |
1158 #undef SET_DIAG_MV | |
1159 } | |
1160 | |
1169 | 1161 if(topright_ref != PART_NOT_AVAILABLE){ |
1162 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
1163 return topright_ref; | |
1164 }else{ | |
1170 | 1165 tprintf("topright MV not available\n"); |
1166 | |
1169 | 1167 *C= h->mv_cache[list][ i - 8 - 1 ]; |
1168 return h->ref_cache[list][ i - 8 - 1 ]; | |
1169 } | |
1170 } | |
1171 | |
1168 | 1172 /** |
1173 * gets the predicted MV. | |
1174 * @param n the block index | |
1175 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
1176 * @param mx the x component of the predicted motion vector | |
1177 * @param my the y component of the predicted motion vector | |
1178 */ | |
1179 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
1180 const int index8= scan8[n]; | |
1181 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
1182 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
1183 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
1184 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 1185 const int16_t * C; |
1186 int diagonal_ref, match_count; | |
1187 | |
1168 | 1188 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 1189 |
1168 | 1190 /* mv_cache |
2967 | 1191 B . . A T T T T |
1168 | 1192 U . . L . . , . |
1193 U . . L . . . . | |
1194 U . . L . . , . | |
1195 . . . L . . . . | |
1196 */ | |
1169 | 1197 |
1198 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
1199 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
|
1200 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 1201 if(match_count > 1){ //most common |
1202 *mx= mid_pred(A[0], B[0], C[0]); | |
1203 *my= mid_pred(A[1], B[1], C[1]); | |
1204 }else if(match_count==1){ | |
1205 if(left_ref==ref){ | |
1206 *mx= A[0]; | |
2967 | 1207 *my= A[1]; |
1169 | 1208 }else if(top_ref==ref){ |
1209 *mx= B[0]; | |
2967 | 1210 *my= B[1]; |
1169 | 1211 }else{ |
1212 *mx= C[0]; | |
2967 | 1213 *my= C[1]; |
1169 | 1214 } |
1215 }else{ | |
1216 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
1217 *mx= A[0]; | |
2967 | 1218 *my= A[1]; |
1168 | 1219 }else{ |
1220 *mx= mid_pred(A[0], B[0], C[0]); | |
1221 *my= mid_pred(A[1], B[1], C[1]); | |
1222 } | |
1169 | 1223 } |
2967 | 1224 |
1187 | 1225 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 | 1226 } |
1227 | |
1228 /** | |
1229 * gets the directionally predicted 16x8 MV. | |
1230 * @param n the block index | |
1231 * @param mx the x component of the predicted motion vector | |
1232 * @param my the y component of the predicted motion vector | |
1233 */ | |
1234 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1235 if(n==0){ | |
1236 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
1237 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
1238 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1239 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 | 1240 |
1168 | 1241 if(top_ref == ref){ |
1242 *mx= B[0]; | |
1243 *my= B[1]; | |
1244 return; | |
1245 } | |
1246 }else{ | |
1247 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
1248 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 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", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1251 |
1252 if(left_ref == ref){ | |
1253 *mx= A[0]; | |
1254 *my= A[1]; | |
1255 return; | |
1256 } | |
1257 } | |
1258 | |
1259 //RARE | |
1260 pred_motion(h, n, 4, list, ref, mx, my); | |
1261 } | |
1262 | |
1263 /** | |
1264 * gets the directionally predicted 8x16 MV. | |
1265 * @param n the block index | |
1266 * @param mx the x component of the predicted motion vector | |
1267 * @param my the y component of the predicted motion vector | |
1268 */ | |
1269 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1270 if(n==0){ | |
1271 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1272 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 1273 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1274 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 | 1275 |
1276 if(left_ref == ref){ | |
1277 *mx= A[0]; | |
1278 *my= A[1]; | |
1279 return; | |
1280 } | |
1281 }else{ | |
1169 | 1282 const int16_t * C; |
1283 int diagonal_ref; | |
1284 | |
1285 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 1286 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1287 tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1288 |
2967 | 1289 if(diagonal_ref == ref){ |
1168 | 1290 *mx= C[0]; |
1291 *my= C[1]; | |
1292 return; | |
1293 } | |
1294 } | |
1295 | |
1296 //RARE | |
1297 pred_motion(h, n, 2, list, ref, mx, my); | |
1298 } | |
1299 | |
1300 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1301 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1302 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1303 | |
2392 | 1304 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1305 |
1306 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1307 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1308 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 1309 |
1168 | 1310 *mx = *my = 0; |
1311 return; | |
1312 } | |
2967 | 1313 |
1168 | 1314 pred_motion(h, 0, 4, 0, 0, mx, my); |
1315 | |
1316 return; | |
1317 } | |
1318 | |
2396 | 1319 static inline void direct_dist_scale_factor(H264Context * const h){ |
1320 const int poc = h->s.current_picture_ptr->poc; | |
1321 const int poc1 = h->ref_list[1][0].poc; | |
1322 int i; | |
1323 for(i=0; i<h->ref_count[0]; i++){ | |
1324 int poc0 = h->ref_list[0][i].poc; | |
4594 | 1325 int td = av_clip(poc1 - poc0, -128, 127); |
2396 | 1326 if(td == 0 /* FIXME || pic0 is a long-term ref */){ |
1327 h->dist_scale_factor[i] = 256; | |
1328 }else{ | |
4594 | 1329 int tb = av_clip(poc - poc0, -128, 127); |
4001 | 1330 int tx = (16384 + (FFABS(td) >> 1)) / td; |
4594 | 1331 h->dist_scale_factor[i] = av_clip((tb*tx + 32) >> 6, -1024, 1023); |
2396 | 1332 } |
1333 } | |
3316 | 1334 if(FRAME_MBAFF){ |
1335 for(i=0; i<h->ref_count[0]; i++){ | |
1336 h->dist_scale_factor_field[2*i] = | |
1337 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
1338 } | |
1339 } | |
2396 | 1340 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1341 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
|
1342 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1343 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
|
1344 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
|
1345 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1346 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1347 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1348 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1349 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1350 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1351 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
|
1352 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
|
1353 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
|
1354 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1355 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
|
1356 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1357 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1358 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
|
1359 const int poc = ref1->ref_poc[list][i]; |
3125 | 1360 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
|
1361 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
|
1362 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
|
1363 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
|
1364 break; |
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 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1367 } |
3316 | 1368 if(FRAME_MBAFF){ |
1369 for(list=0; list<2; list++){ | |
1370 for(i=0; i<ref1->ref_count[list]; i++){ | |
1371 j = h->map_col_to_list0[list][i]; | |
1372 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1373 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1374 } | |
1375 } | |
1376 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1377 } |
2396 | 1378 |
1379 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1380 MpegEncContext * const s = &h->s; | |
1381 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1382 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1383 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1384 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1385 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
|
1386 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1387 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
|
1388 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1389 const int is_b8x8 = IS_8X8(*mb_type); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
1390 unsigned int sub_mb_type; |
2396 | 1391 int i8, i4; |
1392 | |
3316 | 1393 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1394 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1395 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1396 * so we know exactly what block size to use */ | |
1397 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1398 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1399 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1400 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1401 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1402 }else{ | |
1403 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1404 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1405 } |
1406 if(!is_b8x8) | |
1407 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1408 if(MB_FIELD) |
1409 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1410 |
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
|
1411 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 | 1412 |
2396 | 1413 if(h->direct_spatial_mv_pred){ |
1414 int ref[2]; | |
1415 int mv[2][2]; | |
1416 int list; | |
1417 | |
3316 | 1418 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1419 | |
2396 | 1420 /* ref = min(neighbors) */ |
1421 for(list=0; list<2; list++){ | |
1422 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1423 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1424 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1425 if(refc == -2) | |
1426 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1427 ref[list] = refa; | |
1428 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1429 ref[list] = refb; | |
1430 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1431 ref[list] = refc; | |
1432 if(ref[list] < 0) | |
1433 ref[list] = -1; | |
1434 } | |
1435 | |
1436 if(ref[0] < 0 && ref[1] < 0){ | |
1437 ref[0] = ref[1] = 0; | |
1438 mv[0][0] = mv[0][1] = | |
1439 mv[1][0] = mv[1][1] = 0; | |
1440 }else{ | |
1441 for(list=0; list<2; list++){ | |
1442 if(ref[list] >= 0) | |
1443 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1444 else | |
1445 mv[list][0] = mv[list][1] = 0; | |
1446 } | |
1447 } | |
1448 | |
1449 if(ref[1] < 0){ | |
1450 *mb_type &= ~MB_TYPE_P0L1; | |
1451 sub_mb_type &= ~MB_TYPE_P0L1; | |
1452 }else if(ref[0] < 0){ | |
1453 *mb_type &= ~MB_TYPE_P0L0; | |
1454 sub_mb_type &= ~MB_TYPE_P0L0; | |
1455 } | |
1456 | |
1457 if(IS_16X16(*mb_type)){ | |
4540 | 1458 int a=0, b=0; |
1459 | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1460 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
|
1461 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1462 if(!IS_INTRA(mb_type_col) |
4001 | 1463 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1464 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1465 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1466 if(ref[0] > 0) |
4540 | 1467 a= pack16to32(mv[0][0],mv[0][1]); |
2396 | 1468 if(ref[1] > 0) |
4540 | 1469 b= pack16to32(mv[1][0],mv[1][1]); |
2396 | 1470 }else{ |
4540 | 1471 a= pack16to32(mv[0][0],mv[0][1]); |
1472 b= pack16to32(mv[1][0],mv[1][1]); | |
1473 } | |
1474 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4); | |
1475 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4); | |
2396 | 1476 }else{ |
1477 for(i8=0; i8<4; i8++){ | |
1478 const int x8 = i8&1; | |
1479 const int y8 = i8>>1; | |
2967 | 1480 |
2396 | 1481 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1482 continue; | |
1483 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1484 |
2396 | 1485 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1486 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
|
1487 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
|
1488 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1489 |
2396 | 1490 /* col_zero_flag */ |
2967 | 1491 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1492 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1493 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1494 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1495 if(IS_SUB_8X8(sub_mb_type)){ |
1496 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1497 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1498 if(ref[0] == 0) |
1499 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1500 if(ref[1] == 0) | |
1501 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1502 } | |
1503 }else | |
2396 | 1504 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1505 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1506 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1507 if(ref[0] == 0) |
1508 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1509 if(ref[1] == 0) | |
1510 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1511 } | |
1512 } | |
1513 } | |
1514 } | |
1515 } | |
1516 }else{ /* direct temporal mv pred */ | |
3316 | 1517 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1518 const int *dist_scale_factor = h->dist_scale_factor; | |
1519 | |
1520 if(FRAME_MBAFF){ | |
1521 if(IS_INTERLACED(*mb_type)){ | |
1522 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1523 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1524 dist_scale_factor = h->dist_scale_factor_field; | |
1525 } | |
1526 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1527 /* FIXME assumes direct_8x8_inference == 1 */ | |
1528 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1529 int mb_types_col[2]; | |
1530 int y_shift; | |
1531 | |
1532 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1533 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1534 | (*mb_type & MB_TYPE_INTERLACED); | |
1535 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1536 | |
1537 if(IS_INTERLACED(*mb_type)){ | |
1538 /* frame to field scaling */ | |
1539 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1540 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1541 if(s->mb_y&1){ | |
1542 l1ref0 -= 2*h->b8_stride; | |
1543 l1ref1 -= 2*h->b8_stride; | |
1544 l1mv0 -= 4*h->b_stride; | |
1545 l1mv1 -= 4*h->b_stride; | |
1546 } | |
1547 y_shift = 0; | |
1548 | |
1549 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1550 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1551 && !is_b8x8) | |
1552 *mb_type |= MB_TYPE_16x8; | |
1553 else | |
1554 *mb_type |= MB_TYPE_8x8; | |
1555 }else{ | |
1556 /* field to frame scaling */ | |
1557 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1558 * but in MBAFF, top and bottom POC are equal */ | |
1559 int dy = (s->mb_y&1) ? 1 : 2; | |
1560 mb_types_col[0] = | |
1561 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1562 l1ref0 += dy*h->b8_stride; | |
1563 l1ref1 += dy*h->b8_stride; | |
1564 l1mv0 += 2*dy*h->b_stride; | |
1565 l1mv1 += 2*dy*h->b_stride; | |
1566 y_shift = 2; | |
1567 | |
1568 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1569 && !is_b8x8) | |
1570 *mb_type |= MB_TYPE_16x16; | |
1571 else | |
1572 *mb_type |= MB_TYPE_8x8; | |
1573 } | |
1574 | |
1575 for(i8=0; i8<4; i8++){ | |
1576 const int x8 = i8&1; | |
1577 const int y8 = i8>>1; | |
1578 int ref0, scale; | |
1579 const int16_t (*l1mv)[2]= l1mv0; | |
1580 | |
1581 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1582 continue; | |
1583 h->sub_mb_type[i8] = sub_mb_type; | |
1584 | |
1585 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1586 if(IS_INTRA(mb_types_col[y8])){ | |
1587 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1588 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1589 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1590 continue; | |
1591 } | |
1592 | |
1593 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1594 if(ref0 >= 0) | |
1595 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1596 else{ | |
1597 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1598 l1mv= l1mv1; | |
1599 } | |
1600 scale = dist_scale_factor[ref0]; | |
1601 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1602 | |
1603 { | |
1604 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1605 int my_col = (mv_col[1]<<y_shift)/2; | |
1606 int mx = (scale * mv_col[0] + 128) >> 8; | |
1607 int my = (scale * my_col + 128) >> 8; | |
1608 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1609 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1610 } | |
1611 } | |
1612 return; | |
1613 } | |
1614 } | |
1615 | |
1616 /* one-to-one mv scaling */ | |
1617 | |
2396 | 1618 if(IS_16X16(*mb_type)){ |
4541 | 1619 int ref, mv0, mv1; |
1620 | |
2396 | 1621 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); |
1622 if(IS_INTRA(mb_type_col)){ | |
4541 | 1623 ref=mv0=mv1=0; |
2396 | 1624 }else{ |
3316 | 1625 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1626 : map_col_to_list0[1][l1ref1[0]]; | |
1627 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
|
1628 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1629 int mv_l0[2]; |
3316 | 1630 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1631 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
4541 | 1632 ref= ref0; |
1633 mv0= pack16to32(mv_l0[0],mv_l0[1]); | |
1634 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1635 } | |
1636 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); | |
1637 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4); | |
1638 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4); | |
2396 | 1639 }else{ |
1640 for(i8=0; i8<4; i8++){ | |
1641 const int x8 = i8&1; | |
1642 const int y8 = i8>>1; | |
3316 | 1643 int ref0, scale; |
2834 | 1644 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
|
1645 |
2396 | 1646 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1647 continue; | |
1648 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1649 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1650 if(IS_INTRA(mb_type_col)){ |
1651 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1652 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1653 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1654 continue; | |
1655 } | |
2967 | 1656 |
2396 | 1657 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
|
1658 if(ref0 >= 0) |
3316 | 1659 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
|
1660 else{ |
3316 | 1661 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
|
1662 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1663 } |
3316 | 1664 scale = dist_scale_factor[ref0]; |
2967 | 1665 |
2396 | 1666 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1667 if(IS_SUB_8X8(sub_mb_type)){ |
1668 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1669 int mx = (scale * mv_col[0] + 128) >> 8; |
1670 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1671 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1672 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1673 }else | |
2396 | 1674 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
|
1675 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1676 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1677 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1678 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1679 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1680 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1681 } | |
1682 } | |
1683 } | |
1684 } | |
1685 } | |
1686 | |
1168 | 1687 static inline void write_back_motion(H264Context *h, int mb_type){ |
1688 MpegEncContext * const s = &h->s; | |
1689 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1690 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1691 int list; | |
1692 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1693 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1694 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
|
1695 |
4533 | 1696 for(list=0; list<h->list_count; list++){ |
1168 | 1697 int y; |
3212 | 1698 if(!USES_LIST(mb_type, list)) |
2396 | 1699 continue; |
2967 | 1700 |
1168 | 1701 for(y=0; y<4; y++){ |
1702 *(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]; | |
1703 *(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]; | |
1704 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1705 if( h->pps.cabac ) { |
3927 | 1706 if(IS_SKIP(mb_type)) |
1707 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1708 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1709 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
|
1710 *(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
|
1711 *(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
|
1712 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1713 } |
3212 | 1714 |
1715 { | |
3776 | 1716 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1717 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1718 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1719 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1720 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1721 } |
1722 } | |
2967 | 1723 |
2396 | 1724 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1725 if(IS_8X8(mb_type)){ | |
3212 | 1726 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1727 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1728 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1729 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1730 } |
1731 } | |
1168 | 1732 } |
1733 | |
1734 /** | |
1735 * Decodes a network abstraction layer unit. | |
1736 * @param consumed is the number of bytes used as input | |
1737 * @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
|
1738 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1739 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1740 */ |
1741 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1742 int i, si, di; | |
1743 uint8_t *dst; | |
1744 | |
2979 | 1745 // src[0]&0x80; //forbidden bit |
1168 | 1746 h->nal_ref_idc= src[0]>>5; |
1747 h->nal_unit_type= src[0]&0x1F; | |
1748 | |
1749 src++; length--; | |
2967 | 1750 #if 0 |
1168 | 1751 for(i=0; i<length; i++) |
1752 printf("%2X ", src[i]); | |
1753 #endif | |
1754 for(i=0; i+1<length; i+=2){ | |
1755 if(src[i]) continue; | |
1756 if(i>0 && src[i-1]==0) i--; | |
1757 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1758 if(src[i+2]!=3){ | |
1759 /* startcode, so we must be past the end */ | |
1760 length=i; | |
1761 } | |
1762 break; | |
1763 } | |
1764 } | |
1765 | |
1766 if(i>=length-1){ //no escaped 0 | |
1767 *dst_length= length; | |
1768 *consumed= length+1; //+1 for the header | |
2967 | 1769 return src; |
1168 | 1770 } |
1771 | |
1772 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1773 dst= h->rbsp_buffer; | |
1774 | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1775 if (dst == NULL){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1776 return NULL; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1777 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1778 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1779 //printf("decoding esc\n"); |
1168 | 1780 si=di=0; |
2967 | 1781 while(si<length){ |
1168 | 1782 //remove escapes (very rare 1:2^22) |
1783 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1784 if(src[si+2]==3){ //escape | |
1785 dst[di++]= 0; | |
1786 dst[di++]= 0; | |
1787 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1788 continue; |
1168 | 1789 }else //next start code |
1790 break; | |
1791 } | |
1792 | |
1793 dst[di++]= src[si++]; | |
1794 } | |
1795 | |
1796 *dst_length= di; | |
1797 *consumed= si + 1;//+1 for the header | |
1798 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1799 return dst; | |
1800 } | |
1801 | |
1802 /** | |
1803 * identifies the exact end of the bitstream | |
1804 * @return the length of the trailing, or 0 if damaged | |
1805 */ | |
1806 static int decode_rbsp_trailing(uint8_t *src){ | |
1807 int v= *src; | |
1808 int r; | |
1809 | |
1170 | 1810 tprintf("rbsp trailing %X\n", v); |
1168 | 1811 |
1812 for(r=1; r<9; r++){ | |
1813 if(v&1) return r; | |
1814 v>>=1; | |
1815 } | |
1816 return 0; | |
1817 } | |
1818 | |
1819 /** | |
1820 * idct tranforms the 16 dc values and dequantize them. | |
1821 * @param qp quantization parameter | |
1822 */ | |
2919 | 1823 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1824 #define stride 16 |
1825 int i; | |
1826 int temp[16]; //FIXME check if this is a good idea | |
1827 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1828 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1829 | |
1830 //memset(block, 64, 2*256); | |
1831 //return; | |
1832 for(i=0; i<4; i++){ | |
1833 const int offset= y_offset[i]; | |
1834 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1835 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1836 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1837 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1838 | |
1839 temp[4*i+0]= z0+z3; | |
1840 temp[4*i+1]= z1+z2; | |
1841 temp[4*i+2]= z1-z2; | |
1842 temp[4*i+3]= z0-z3; | |
1843 } | |
1844 | |
1845 for(i=0; i<4; i++){ | |
1846 const int offset= x_offset[i]; | |
1847 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1848 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1849 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1850 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1851 | |
2919 | 1852 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1853 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1854 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1855 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1856 } |
1857 } | |
1858 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1859 #if 0 |
1168 | 1860 /** |
1861 * dct tranforms the 16 dc values. | |
1862 * @param qp quantization parameter ??? FIXME | |
1863 */ | |
1864 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1865 // const int qmul= dequant_coeff[qp][0]; | |
1866 int i; | |
1867 int temp[16]; //FIXME check if this is a good idea | |
1868 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1869 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1870 | |
1871 for(i=0; i<4; i++){ | |
1872 const int offset= y_offset[i]; | |
1873 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1874 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1875 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1876 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1877 | |
1878 temp[4*i+0]= z0+z3; | |
1879 temp[4*i+1]= z1+z2; | |
1880 temp[4*i+2]= z1-z2; | |
1881 temp[4*i+3]= z0-z3; | |
1882 } | |
1883 | |
1884 for(i=0; i<4; i++){ | |
1885 const int offset= x_offset[i]; | |
1886 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1887 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1888 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1889 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1890 | |
1891 block[stride*0 +offset]= (z0 + z3)>>1; | |
1892 block[stride*2 +offset]= (z1 + z2)>>1; | |
1893 block[stride*8 +offset]= (z1 - z2)>>1; | |
1894 block[stride*10+offset]= (z0 - z3)>>1; | |
1895 } | |
1896 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1897 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1898 |
1168 | 1899 #undef xStride |
1900 #undef stride | |
1901 | |
2919 | 1902 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1903 const int stride= 16*2; |
1904 const int xStride= 16; | |
1905 int a,b,c,d,e; | |
1906 | |
1907 a= block[stride*0 + xStride*0]; | |
1908 b= block[stride*0 + xStride*1]; | |
1909 c= block[stride*1 + xStride*0]; | |
1910 d= block[stride*1 + xStride*1]; | |
1911 | |
1912 e= a-b; | |
1913 a= a+b; | |
1914 b= c-d; | |
1915 c= c+d; | |
1916 | |
2919 | 1917 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1918 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1919 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1920 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1921 } |
1922 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1923 #if 0 |
1168 | 1924 static void chroma_dc_dct_c(DCTELEM *block){ |
1925 const int stride= 16*2; | |
1926 const int xStride= 16; | |
1927 int a,b,c,d,e; | |
1928 | |
1929 a= block[stride*0 + xStride*0]; | |
1930 b= block[stride*0 + xStride*1]; | |
1931 c= block[stride*1 + xStride*0]; | |
1932 d= block[stride*1 + xStride*1]; | |
1933 | |
1934 e= a-b; | |
1935 a= a+b; | |
1936 b= c-d; | |
1937 c= c+d; | |
1938 | |
1939 block[stride*0 + xStride*0]= (a+c); | |
1940 block[stride*0 + xStride*1]= (e+b); | |
1941 block[stride*1 + xStride*0]= (a-c); | |
1942 block[stride*1 + xStride*1]= (e-b); | |
1943 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1944 #endif |
1168 | 1945 |
1946 /** | |
1947 * gets the chroma qp. | |
1948 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1949 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 1950 |
4594 | 1951 return chroma_qp[av_clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 1952 } |
1953 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1954 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close |
4553
1a714d3f0233
cosmetics: Fix a common typo, sepErate --> sepArate.
diego
parents:
4546
diff
changeset
|
1955 //FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away) |
1a714d3f0233
cosmetics: Fix a common typo, sepErate --> sepArate.
diego
parents:
4546
diff
changeset
|
1956 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int separate_dc){ |
1168 | 1957 int i; |
1958 const int * const quant_table= quant_coeff[qscale]; | |
1959 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1960 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1961 const unsigned int threshold2= (threshold1<<1); | |
1962 int last_non_zero; | |
1963 | |
4553
1a714d3f0233
cosmetics: Fix a common typo, sepErate --> sepArate.
diego
parents:
4546
diff
changeset
|
1964 if(separate_dc){ |
1168 | 1965 if(qscale<=18){ |
1966 //avoid overflows | |
1967 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1968 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1969 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1970 | |
1971 int level= block[0]*quant_coeff[qscale+18][0]; | |
1972 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1973 if(level>0){ | |
1974 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1975 block[0]= level; | |
1976 }else{ | |
1977 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1978 block[0]= -level; | |
1979 } | |
1980 // last_non_zero = i; | |
1981 }else{ | |
1982 block[0]=0; | |
1983 } | |
1984 }else{ | |
1985 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1986 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1987 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1988 | |
1989 int level= block[0]*quant_table[0]; | |
1990 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1991 if(level>0){ | |
1992 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
1993 block[0]= level; | |
1994 }else{ | |
1995 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
1996 block[0]= -level; | |
1997 } | |
1998 // last_non_zero = i; | |
1999 }else{ | |
2000 block[0]=0; | |
2001 } | |
2002 } | |
2003 last_non_zero= 0; | |
2004 i=1; | |
2005 }else{ | |
2006 last_non_zero= -1; | |
2007 i=0; | |
2008 } | |
2009 | |
2010 for(; i<16; i++){ | |
2011 const int j= scantable[i]; | |
2012 int level= block[j]*quant_table[j]; | |
2013 | |
2014 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
2015 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
2016 if(((unsigned)(level+threshold1))>threshold2){ | |
2017 if(level>0){ | |
2018 level= (bias + level)>>QUANT_SHIFT; | |
2019 block[j]= level; | |
2020 }else{ | |
2021 level= (bias - level)>>QUANT_SHIFT; | |
2022 block[j]= -level; | |
2023 } | |
2024 last_non_zero = i; | |
2025 }else{ | |
2026 block[j]=0; | |
2027 } | |
2028 } | |
2029 | |
2030 return last_non_zero; | |
2031 } | |
2032 | |
2033 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
2034 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2035 ((uint32_t*)(src+0*stride))[0]= a; | |
2036 ((uint32_t*)(src+1*stride))[0]= a; | |
2037 ((uint32_t*)(src+2*stride))[0]= a; | |
2038 ((uint32_t*)(src+3*stride))[0]= a; | |
2039 } | |
2040 | |
2041 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
2042 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
2043 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
2044 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
2045 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
2046 } | |
2047 | |
2048 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2049 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
2050 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 2051 |
2052 ((uint32_t*)(src+0*stride))[0]= | |
2053 ((uint32_t*)(src+1*stride))[0]= | |
2054 ((uint32_t*)(src+2*stride))[0]= | |
2055 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2056 } |
2057 | |
2058 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2059 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 2060 |
2061 ((uint32_t*)(src+0*stride))[0]= | |
2062 ((uint32_t*)(src+1*stride))[0]= | |
2063 ((uint32_t*)(src+2*stride))[0]= | |
2064 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2065 } |
2066 | |
2067 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2068 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 2069 |
2070 ((uint32_t*)(src+0*stride))[0]= | |
2071 ((uint32_t*)(src+1*stride))[0]= | |
2072 ((uint32_t*)(src+2*stride))[0]= | |
2073 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2074 } |
2075 | |
2076 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2077 ((uint32_t*)(src+0*stride))[0]= |
2078 ((uint32_t*)(src+1*stride))[0]= | |
2079 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 2080 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
2081 } | |
2082 | |
2083 | |
2084 #define LOAD_TOP_RIGHT_EDGE\ | |
2085 const int t4= topright[0];\ | |
2086 const int t5= topright[1];\ | |
2087 const int t6= topright[2];\ | |
2088 const int t7= topright[3];\ | |
2089 | |
2090 #define LOAD_LEFT_EDGE\ | |
2091 const int l0= src[-1+0*stride];\ | |
2092 const int l1= src[-1+1*stride];\ | |
2093 const int l2= src[-1+2*stride];\ | |
2094 const int l3= src[-1+3*stride];\ | |
2095 | |
2096 #define LOAD_TOP_EDGE\ | |
2097 const int t0= src[ 0-1*stride];\ | |
2098 const int t1= src[ 1-1*stride];\ | |
2099 const int t2= src[ 2-1*stride];\ | |
2100 const int t3= src[ 3-1*stride];\ | |
2101 | |
2102 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2103 const int lt= src[-1-1*stride]; | |
2104 LOAD_TOP_EDGE | |
2105 LOAD_LEFT_EDGE | |
2106 | |
2967 | 2107 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 2108 src[0+2*stride]= |
2967 | 2109 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 2110 src[0+1*stride]= |
2111 src[1+2*stride]= | |
2967 | 2112 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 2113 src[0+0*stride]= |
2114 src[1+1*stride]= | |
2115 src[2+2*stride]= | |
2967 | 2116 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 2117 src[1+0*stride]= |
2118 src[2+1*stride]= | |
2119 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2120 src[2+0*stride]= | |
2121 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2122 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 2123 } |
1168 | 2124 |
2125 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2126 LOAD_TOP_EDGE |
2127 LOAD_TOP_RIGHT_EDGE | |
2128 // LOAD_LEFT_EDGE | |
1168 | 2129 |
2130 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
2131 src[1+0*stride]= | |
2132 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
2133 src[2+0*stride]= | |
2134 src[1+1*stride]= | |
2135 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
2136 src[3+0*stride]= | |
2137 src[2+1*stride]= | |
2138 src[1+2*stride]= | |
2139 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
2140 src[3+1*stride]= | |
2141 src[2+2*stride]= | |
2142 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
2143 src[3+2*stride]= | |
2144 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
2145 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 2146 } |
1168 | 2147 |
2148 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2149 const int lt= src[-1-1*stride]; | |
2967 | 2150 LOAD_TOP_EDGE |
2151 LOAD_LEFT_EDGE | |
1168 | 2152 const __attribute__((unused)) int unu= l3; |
2153 | |
2154 src[0+0*stride]= | |
2155 src[1+2*stride]=(lt + t0 + 1)>>1; | |
2156 src[1+0*stride]= | |
2157 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
2158 src[2+0*stride]= | |
2159 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
2160 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
2161 src[0+1*stride]= | |
2162 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2163 src[1+1*stride]= | |
2164 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2165 src[2+1*stride]= | |
2166 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2167 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2168 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2169 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 2170 } |
1168 | 2171 |
2172 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2173 LOAD_TOP_EDGE |
2174 LOAD_TOP_RIGHT_EDGE | |
1168 | 2175 const __attribute__((unused)) int unu= t7; |
2176 | |
2177 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
2178 src[1+0*stride]= | |
2179 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
2180 src[2+0*stride]= | |
2181 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
2182 src[3+0*stride]= | |
2183 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
2184 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
2185 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2186 src[1+1*stride]= | |
2187 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2188 src[2+1*stride]= | |
2189 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
2190 src[3+1*stride]= | |
2191 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
2192 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 2193 } |
1168 | 2194 |
2195 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2196 LOAD_LEFT_EDGE |
1168 | 2197 |
2198 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
2199 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2200 src[2+0*stride]= | |
2201 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
2202 src[3+0*stride]= | |
2203 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
2204 src[2+1*stride]= | |
2205 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
2206 src[3+1*stride]= | |
2207 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
2208 src[3+2*stride]= | |
2209 src[1+3*stride]= | |
2210 src[0+3*stride]= | |
2211 src[2+2*stride]= | |
2212 src[2+3*stride]= | |
2213 src[3+3*stride]=l3; | |
1282 | 2214 } |
2967 | 2215 |
1168 | 2216 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
2217 const int lt= src[-1-1*stride]; | |
2967 | 2218 LOAD_TOP_EDGE |
2219 LOAD_LEFT_EDGE | |
1168 | 2220 const __attribute__((unused)) int unu= t3; |
2221 | |
2222 src[0+0*stride]= | |
2223 src[2+1*stride]=(lt + l0 + 1)>>1; | |
2224 src[1+0*stride]= | |
2225 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2226 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2227 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2228 src[0+1*stride]= | |
2229 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
2230 src[1+1*stride]= | |
2231 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2232 src[0+2*stride]= | |
2233 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
2234 src[1+2*stride]= | |
2235 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2236 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
2237 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 2238 } |
1168 | 2239 |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2240 void ff_pred16x16_vertical_c(uint8_t *src, int stride){ |
1168 | 2241 int i; |
2242 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2243 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2244 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
2245 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 2246 |
1168 | 2247 for(i=0; i<16; i++){ |
2248 ((uint32_t*)(src+i*stride))[0]= a; | |
2249 ((uint32_t*)(src+i*stride))[1]= b; | |
2250 ((uint32_t*)(src+i*stride))[2]= c; | |
2251 ((uint32_t*)(src+i*stride))[3]= d; | |
2252 } | |
2253 } | |
2254 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2255 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){ |
1168 | 2256 int i; |
2257 | |
2258 for(i=0; i<16; i++){ | |
2259 ((uint32_t*)(src+i*stride))[0]= | |
2260 ((uint32_t*)(src+i*stride))[1]= | |
2261 ((uint32_t*)(src+i*stride))[2]= | |
2262 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
2263 } | |
2264 } | |
2265 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2266 void ff_pred16x16_dc_c(uint8_t *src, int stride){ |
1168 | 2267 int i, dc=0; |
2268 | |
2269 for(i=0;i<16; i++){ | |
2270 dc+= src[-1+i*stride]; | |
2271 } | |
2967 | 2272 |
1168 | 2273 for(i=0;i<16; i++){ |
2274 dc+= src[i-stride]; | |
2275 } | |
2276 | |
2277 dc= 0x01010101*((dc + 16)>>5); | |
2278 | |
2279 for(i=0; i<16; i++){ | |
2280 ((uint32_t*)(src+i*stride))[0]= | |
2281 ((uint32_t*)(src+i*stride))[1]= | |
2282 ((uint32_t*)(src+i*stride))[2]= | |
2283 ((uint32_t*)(src+i*stride))[3]= dc; | |
2284 } | |
2285 } | |
2286 | |
2287 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
2288 int i, dc=0; | |
2289 | |
2290 for(i=0;i<16; i++){ | |
2291 dc+= src[-1+i*stride]; | |
2292 } | |
2967 | 2293 |
1168 | 2294 dc= 0x01010101*((dc + 8)>>4); |
2295 | |
2296 for(i=0; i<16; i++){ | |
2297 ((uint32_t*)(src+i*stride))[0]= | |
2298 ((uint32_t*)(src+i*stride))[1]= | |
2299 ((uint32_t*)(src+i*stride))[2]= | |
2300 ((uint32_t*)(src+i*stride))[3]= dc; | |
2301 } | |
2302 } | |
2303 | |
2304 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
2305 int i, dc=0; | |
2306 | |
2307 for(i=0;i<16; i++){ | |
2308 dc+= src[i-stride]; | |
2309 } | |
2310 dc= 0x01010101*((dc + 8)>>4); | |
2311 | |
2312 for(i=0; i<16; i++){ | |
2313 ((uint32_t*)(src+i*stride))[0]= | |
2314 ((uint32_t*)(src+i*stride))[1]= | |
2315 ((uint32_t*)(src+i*stride))[2]= | |
2316 ((uint32_t*)(src+i*stride))[3]= dc; | |
2317 } | |
2318 } | |
2319 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2320 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){ |
1168 | 2321 int i; |
2322 | |
2323 for(i=0; i<16; i++){ | |
2324 ((uint32_t*)(src+i*stride))[0]= | |
2325 ((uint32_t*)(src+i*stride))[1]= | |
2326 ((uint32_t*)(src+i*stride))[2]= | |
2327 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
2328 } | |
2329 } | |
2330 | |
1234 | 2331 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
|
2332 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2333 int a; |
4176 | 2334 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
|
2335 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
|
2336 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
|
2337 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
|
2338 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
|
2339 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
|
2340 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
|
2341 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2342 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
|
2343 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
|
2344 } |
1234 | 2345 if(svq3){ |
2346 H = ( 5*(H/4) ) / 16; | |
2347 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2348 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2349 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2350 i = H; H = V; V = i; |
1234 | 2351 }else{ |
2352 H = ( 5*H+32 ) >> 6; | |
2353 V = ( 5*V+32 ) >> 6; | |
2354 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2355 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2356 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
|
2357 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
|
2358 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2359 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2360 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
|
2361 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
|
2362 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
|
2363 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
|
2364 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
|
2365 b += 4*H; |
1168 | 2366 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2367 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2368 } |
1168 | 2369 } |
2370 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2371 void ff_pred16x16_plane_c(uint8_t *src, int stride){ |
1234 | 2372 pred16x16_plane_compat_c(src, stride, 0); |
2373 } | |
2374 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2375 void ff_pred8x8_vertical_c(uint8_t *src, int stride){ |
1168 | 2376 int i; |
2377 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2378 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2379 |
1168 | 2380 for(i=0; i<8; i++){ |
2381 ((uint32_t*)(src+i*stride))[0]= a; | |
2382 ((uint32_t*)(src+i*stride))[1]= b; | |
2383 } | |
2384 } | |
2385 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2386 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){ |
1168 | 2387 int i; |
2388 | |
2389 for(i=0; i<8; i++){ | |
2390 ((uint32_t*)(src+i*stride))[0]= | |
2391 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2392 } | |
2393 } | |
2394 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2395 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){ |
1168 | 2396 int i; |
2397 | |
2755 | 2398 for(i=0; i<8; i++){ |
2967 | 2399 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2400 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2401 } | |
2402 } | |
2403 | |
2404 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2405 int i; | |
2406 int dc0, dc2; | |
2407 | |
2408 dc0=dc2=0; | |
2409 for(i=0;i<4; i++){ | |
2410 dc0+= src[-1+i*stride]; | |
2411 dc2+= src[-1+(i+4)*stride]; | |
2412 } | |
2413 dc0= 0x01010101*((dc0 + 2)>>2); | |
2414 dc2= 0x01010101*((dc2 + 2)>>2); | |
2415 | |
2416 for(i=0; i<4; i++){ | |
2417 ((uint32_t*)(src+i*stride))[0]= | |
2418 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2419 } | |
2420 for(i=4; i<8; i++){ | |
2421 ((uint32_t*)(src+i*stride))[0]= | |
2422 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2423 } | |
2424 } | |
2425 | |
2426 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2427 int i; | |
2428 int dc0, dc1; | |
2429 | |
2430 dc0=dc1=0; | |
2431 for(i=0;i<4; i++){ | |
2432 dc0+= src[i-stride]; | |
2433 dc1+= src[4+i-stride]; | |
2434 } | |
2435 dc0= 0x01010101*((dc0 + 2)>>2); | |
2436 dc1= 0x01010101*((dc1 + 2)>>2); | |
2437 | |
2438 for(i=0; i<4; i++){ | |
2439 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2440 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2441 } | |
2442 for(i=4; i<8; i++){ | |
2443 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2444 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2445 } | |
2446 } | |
2447 | |
2448 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2449 void ff_pred8x8_dc_c(uint8_t *src, int stride){ |
1168 | 2450 int i; |
2451 int dc0, dc1, dc2, dc3; | |
2452 | |
2453 dc0=dc1=dc2=0; | |
2454 for(i=0;i<4; i++){ | |
2455 dc0+= src[-1+i*stride] + src[i-stride]; | |
2456 dc1+= src[4+i-stride]; | |
2457 dc2+= src[-1+(i+4)*stride]; | |
2458 } | |
2459 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2460 dc0= 0x01010101*((dc0 + 4)>>3); | |
2461 dc1= 0x01010101*((dc1 + 2)>>2); | |
2462 dc2= 0x01010101*((dc2 + 2)>>2); | |
2463 | |
2464 for(i=0; i<4; i++){ | |
2465 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2466 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2467 } | |
2468 for(i=4; i<8; i++){ | |
2469 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2470 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2471 } | |
2472 } | |
2473 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2474 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
|
2475 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2476 int a; |
4176 | 2477 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
|
2478 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
|
2479 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
|
2480 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
|
2481 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
|
2482 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
|
2483 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
|
2484 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2485 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
|
2486 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
|
2487 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2488 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2489 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2490 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2491 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
|
2492 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
|
2493 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2494 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2495 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2496 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
|
2497 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
|
2498 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
|
2499 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
|
2500 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
|
2501 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
|
2502 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
|
2503 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2504 } |
1168 | 2505 } |
2506 | |
2755 | 2507 #define SRC(x,y) src[(x)+(y)*stride] |
2508 #define PL(y) \ | |
2509 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2510 #define PREDICT_8x8_LOAD_LEFT \ | |
2511 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2512 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2513 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2514 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2515 |
2516 #define PT(x) \ | |
2517 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2518 #define PREDICT_8x8_LOAD_TOP \ | |
2519 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2520 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2521 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2522 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2523 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2524 |
2525 #define PTR(x) \ | |
2526 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2527 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2528 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2529 if(has_topright) { \ | |
2530 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2531 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2532 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2533 | |
2534 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2535 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2536 |
2537 #define PREDICT_8x8_DC(v) \ | |
2538 int y; \ | |
2539 for( y = 0; y < 8; y++ ) { \ | |
2540 ((uint32_t*)src)[0] = \ | |
2541 ((uint32_t*)src)[1] = v; \ | |
2542 src += stride; \ | |
2543 } | |
2544 | |
2545 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2546 { | |
2547 PREDICT_8x8_DC(0x80808080); | |
2548 } | |
2549 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2550 { | |
2551 PREDICT_8x8_LOAD_LEFT; | |
2552 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2553 PREDICT_8x8_DC(dc); | |
2554 } | |
2555 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2556 { | |
2557 PREDICT_8x8_LOAD_TOP; | |
2558 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2559 PREDICT_8x8_DC(dc); | |
2560 } | |
2561 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2562 { | |
2563 PREDICT_8x8_LOAD_LEFT; | |
2564 PREDICT_8x8_LOAD_TOP; | |
2565 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2566 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2567 PREDICT_8x8_DC(dc); | |
2568 } | |
2569 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2570 { | |
2571 PREDICT_8x8_LOAD_LEFT; | |
2572 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2573 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2574 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2575 #undef ROW | |
2576 } | |
2577 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2578 { | |
2579 int y; | |
2580 PREDICT_8x8_LOAD_TOP; | |
2581 src[0] = t0; | |
2582 src[1] = t1; | |
2583 src[2] = t2; | |
2584 src[3] = t3; | |
2585 src[4] = t4; | |
2586 src[5] = t5; | |
2587 src[6] = t6; | |
2588 src[7] = t7; | |
2589 for( y = 1; y < 8; y++ ) | |
2590 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2591 } | |
2592 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2593 { | |
2594 PREDICT_8x8_LOAD_TOP; | |
2595 PREDICT_8x8_LOAD_TOPRIGHT; | |
2596 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2597 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2598 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2599 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2600 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2601 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2602 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; | |
2603 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; | |
2604 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; | |
2605 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2606 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2607 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2608 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2609 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2610 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2611 } | |
2612 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2613 { | |
2614 PREDICT_8x8_LOAD_TOP; | |
2615 PREDICT_8x8_LOAD_LEFT; | |
2616 PREDICT_8x8_LOAD_TOPLEFT; | |
2617 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2618 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2619 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2620 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2621 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2622 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2623 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; | |
2624 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; | |
2625 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; | |
2626 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2627 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2628 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2629 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2630 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2631 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2632 |
2755 | 2633 } |
2634 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2635 { | |
2636 PREDICT_8x8_LOAD_TOP; | |
2637 PREDICT_8x8_LOAD_LEFT; | |
2638 PREDICT_8x8_LOAD_TOPLEFT; | |
2639 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2640 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2641 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2642 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2643 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2644 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2645 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2646 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2647 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2648 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2649 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2650 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2651 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2652 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2653 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2654 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2655 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2656 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2657 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2658 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2659 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2660 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2661 } | |
2662 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2663 { | |
2664 PREDICT_8x8_LOAD_TOP; | |
2665 PREDICT_8x8_LOAD_LEFT; | |
2666 PREDICT_8x8_LOAD_TOPLEFT; | |
2667 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2668 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2669 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2670 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2671 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2672 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2673 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2674 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2675 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2676 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2677 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2678 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2679 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2680 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2681 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2682 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2683 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2684 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2685 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2686 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2687 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2688 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2689 } | |
2690 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2691 { | |
2692 PREDICT_8x8_LOAD_TOP; | |
2693 PREDICT_8x8_LOAD_TOPRIGHT; | |
2694 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2695 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2696 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2697 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2698 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2699 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2700 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2701 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2702 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2703 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2704 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2705 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2706 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2707 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2708 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2709 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2710 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2711 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2712 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2713 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2714 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2715 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2716 } | |
2717 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2718 { | |
2719 PREDICT_8x8_LOAD_LEFT; | |
2720 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2721 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2722 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2723 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2724 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2725 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2726 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2727 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2728 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2729 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2730 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2731 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2732 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2733 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2734 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2735 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2736 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2737 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2738 } | |
2739 #undef PREDICT_8x8_LOAD_LEFT | |
2740 #undef PREDICT_8x8_LOAD_TOP | |
2741 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2742 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2743 #undef PREDICT_8x8_DC | |
2744 #undef PTR | |
2745 #undef PT | |
2746 #undef PL | |
2747 #undef SRC | |
2748 | |
1168 | 2749 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2750 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2751 int src_x_offset, int src_y_offset, | |
2752 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2753 MpegEncContext * const s = &h->s; | |
2754 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2755 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2756 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2757 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2758 uint8_t * src_cb, * src_cr; | |
2759 int extra_width= h->emu_edge_width; | |
2760 int extra_height= h->emu_edge_height; | |
1168 | 2761 int emu=0; |
2762 const int full_mx= mx>>2; | |
2763 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2764 const int pic_width = 16*s->mb_width; |
3316 | 2765 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2766 |
4390 | 2767 if(!pic->data[0]) //FIXME this is unacceptable, some senseable error concealment must be done for missing reference frames |
3125 | 2768 return; |
2967 | 2769 |
1168 | 2770 if(mx&7) extra_width -= 3; |
2771 if(my&7) extra_height -= 3; | |
2967 | 2772 |
2773 if( full_mx < 0-extra_width | |
2774 || full_my < 0-extra_height | |
2775 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2776 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2777 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); |
2778 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2779 emu=1; |
2780 } | |
2967 | 2781 |
3316 | 2782 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2783 if(!square){ |
3316 | 2784 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2785 } |
2967 | 2786 |
1168 | 2787 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2788 |
3316 | 2789 if(MB_MBAFF){ |
2790 // chroma offset when predicting from a field of opposite parity | |
2791 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2792 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2793 } | |
2794 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2795 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2796 |
2797 if(emu){ | |
3316 | 2798 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); |
2799 src_cb= s->edge_emu_buffer; | |
2800 } | |
2801 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2802 | |
2803 if(emu){ | |
2804 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 | 2805 src_cr= s->edge_emu_buffer; |
2806 } | |
3316 | 2807 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2808 } |
2809 | |
2415 | 2810 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2811 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2812 int x_offset, int y_offset, | |
2813 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2814 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2815 int list0, int list1){ | |
2816 MpegEncContext * const s = &h->s; | |
2817 qpel_mc_func *qpix_op= qpix_put; | |
2818 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2819 |
3316 | 2820 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2821 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2822 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2823 x_offset += 8*s->mb_x; |
3316 | 2824 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2825 |
1168 | 2826 if(list0){ |
1169 | 2827 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2828 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2829 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2830 qpix_op, chroma_op); | |
2831 | |
2832 qpix_op= qpix_avg; | |
2833 chroma_op= chroma_avg; | |
2834 } | |
2835 | |
2836 if(list1){ | |
1169 | 2837 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2838 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2839 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2840 qpix_op, chroma_op); | |
2841 } | |
2842 } | |
2843 | |
2415 | 2844 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2845 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2846 int x_offset, int y_offset, | |
2847 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2848 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2849 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2850 int list0, int list1){ | |
2851 MpegEncContext * const s = &h->s; | |
2852 | |
3316 | 2853 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2854 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2855 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2856 x_offset += 8*s->mb_x; |
3316 | 2857 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2858 |
2415 | 2859 if(list0 && list1){ |
2860 /* don't optimize for luma-only case, since B-frames usually | |
2861 * use implicit weights => chroma too. */ | |
2862 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2863 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2864 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2865 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2866 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2867 | |
2868 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2869 dest_y, dest_cb, dest_cr, | |
2870 x_offset, y_offset, qpix_put, chroma_put); | |
2871 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2872 tmp_y, tmp_cb, tmp_cr, | |
2873 x_offset, y_offset, qpix_put, chroma_put); | |
2874 | |
2875 if(h->use_weight == 2){ | |
2876 int weight0 = h->implicit_weight[refn0][refn1]; | |
2877 int weight1 = 64 - weight0; | |
3316 | 2878 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2879 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2880 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 2881 }else{ |
3316 | 2882 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 2883 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 2884 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 2885 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2886 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 2887 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 2888 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2889 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 2890 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 2891 } |
2892 }else{ | |
2893 int list = list1 ? 1 : 0; | |
2894 int refn = h->ref_cache[list][ scan8[n] ]; | |
2895 Picture *ref= &h->ref_list[list][refn]; | |
2896 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2897 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2898 qpix_put, chroma_put); | |
2899 | |
3316 | 2900 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 2901 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
2902 if(h->use_weight_chroma){ | |
3316 | 2903 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2904 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 2905 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2906 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
2907 } | |
2908 } | |
2909 } | |
2910 | |
2911 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2912 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2913 int x_offset, int y_offset, | |
2914 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2915 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 2916 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 2917 int list0, int list1){ |
2918 if((h->use_weight==2 && list0 && list1 | |
2919 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2920 || h->use_weight==1) | |
2921 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2922 x_offset, y_offset, qpix_put, chroma_put, | |
2923 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2924 else | |
2925 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2926 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2927 } | |
2928 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2929 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
|
2930 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2931 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2932 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2933 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
|
2934 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2935 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
|
2936 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
|
2937 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 2938 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
|
2939 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
|
2940 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
|
2941 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
|
2942 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2943 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2944 |
1168 | 2945 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2946 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2947 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2948 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2949 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
|
2950 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2951 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 2952 |
1168 | 2953 assert(IS_INTER(mb_type)); |
2967 | 2954 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2955 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2956 |
1168 | 2957 if(IS_16X16(mb_type)){ |
2958 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2959 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2960 &weight_op[0], &weight_avg[0], |
1168 | 2961 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2962 }else if(IS_16X8(mb_type)){ | |
2963 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2964 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2965 &weight_op[1], &weight_avg[1], |
1168 | 2966 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2967 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
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, 1, 0), IS_DIR(mb_type, 1, 1)); |
2971 }else if(IS_8X16(mb_type)){ | |
3316 | 2972 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 2973 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2974 &weight_op[2], &weight_avg[2], |
1168 | 2975 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 2976 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 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, 1, 0), IS_DIR(mb_type, 1, 1)); |
2980 }else{ | |
2981 int i; | |
2967 | 2982 |
1168 | 2983 assert(IS_8X8(mb_type)); |
2984 | |
2985 for(i=0; i<4; i++){ | |
2986 const int sub_mb_type= h->sub_mb_type[i]; | |
2987 const int n= 4*i; | |
2988 int x_offset= (i&1)<<2; | |
2989 int y_offset= (i&2)<<1; | |
2990 | |
2991 if(IS_SUB_8X8(sub_mb_type)){ | |
2992 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2993 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 2994 &weight_op[3], &weight_avg[3], |
1168 | 2995 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2996 }else if(IS_SUB_8X4(sub_mb_type)){ | |
2997 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2998 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 2999 &weight_op[4], &weight_avg[4], |
1168 | 3000 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3001 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
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 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 3006 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 3007 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3008 &weight_op[5], &weight_avg[5], |
1168 | 3009 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 3010 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, 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)); |
3014 }else{ | |
3015 int j; | |
3016 assert(IS_SUB_4X4(sub_mb_type)); | |
3017 for(j=0; j<4; j++){ | |
3018 int sub_x_offset= x_offset + 2*(j&1); | |
3019 int sub_y_offset= y_offset + (j&2); | |
3020 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
3021 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 3022 &weight_op[6], &weight_avg[6], |
1168 | 3023 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3024 } | |
3025 } | |
3026 } | |
3027 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3028 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3029 prefetch_motion(h, 1); |
1168 | 3030 } |
3031 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3032 static void decode_init_vlc(){ |
1168 | 3033 static int done = 0; |
3034 | |
3035 if (!done) { | |
3036 int i; | |
3037 done = 1; | |
3038 | |
2967 | 3039 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 3040 &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
|
3041 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 3042 |
3043 for(i=0; i<4; i++){ | |
2967 | 3044 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 3045 &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
|
3046 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 3047 } |
3048 | |
3049 for(i=0; i<3; i++){ | |
3050 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
3051 &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
|
3052 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3053 } |
3054 for(i=0; i<15; i++){ | |
2967 | 3055 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 3056 &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
|
3057 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3058 } |
3059 | |
3060 for(i=0; i<6; i++){ | |
2967 | 3061 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 3062 &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
|
3063 &run_bits[i][0], 1, 1, 1); |
1168 | 3064 } |
2967 | 3065 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 3066 &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
|
3067 &run_bits[6][0], 1, 1, 1); |
1168 | 3068 } |
3069 } | |
3070 | |
3071 /** | |
3072 * Sets the intra prediction function pointers. | |
3073 */ | |
3074 static void init_pred_ptrs(H264Context *h){ | |
3075 // MpegEncContext * const s = &h->s; | |
3076 | |
3077 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
3078 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
3079 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
3080 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
3081 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
3082 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
3083 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
3084 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
3085 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
3086 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
3087 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
3088 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
3089 | |
2755 | 3090 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
3091 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
3092 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
3093 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
3094 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
3095 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
3096 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
3097 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
3098 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
3099 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
3100 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
3101 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
3102 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3103 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3104 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3105 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3106 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c; |
1168 | 3107 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; |
3108 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
|
3109 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
|
3110 |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3111 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3112 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3113 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3114 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c; |
1168 | 3115 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; |
3116 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
|
3117 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c; |
1168 | 3118 } |
3119 | |
3120 static void free_tables(H264Context *h){ | |
3121 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
|
3122 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
|
3123 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
|
3124 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
|
3125 av_freep(&h->mvd_table[1]); |
2396 | 3126 av_freep(&h->direct_table); |
1168 | 3127 av_freep(&h->non_zero_count); |
3128 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
|
3129 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3130 av_freep(&h->top_borders[0]); |
1168 | 3131 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
|
3132 |
1168 | 3133 av_freep(&h->mb2b_xy); |
3134 av_freep(&h->mb2b8_xy); | |
2415 | 3135 |
3136 av_freep(&h->s.obmc_scratchpad); | |
1168 | 3137 } |
3138 | |
2919 | 3139 static void init_dequant8_coeff_table(H264Context *h){ |
3140 int i,q,x; | |
3174 | 3141 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 3142 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
3143 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
3144 | |
3145 for(i=0; i<2; i++ ){ | |
3146 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
3147 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
3148 break; | |
3149 } | |
3150 | |
3151 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3152 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3153 int idx = ff_rem6[q]; |
2919 | 3154 for(x=0; x<64; x++) |
3174 | 3155 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
3156 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
3157 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 3158 } |
3159 } | |
3160 } | |
3161 | |
3162 static void init_dequant4_coeff_table(H264Context *h){ | |
3163 int i,j,q,x; | |
3005 | 3164 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 3165 for(i=0; i<6; i++ ){ |
3166 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
3167 for(j=0; j<i; j++){ | |
3168 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
3169 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
3170 break; | |
3171 } | |
3172 } | |
3173 if(j<i) | |
3174 continue; | |
3175 | |
3176 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3177 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3178 int idx = ff_rem6[q]; |
2919 | 3179 for(x=0; x<16; x++) |
3005 | 3180 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
3181 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 3182 h->pps.scaling_matrix4[i][x]) << shift; |
3183 } | |
3184 } | |
3185 } | |
3186 | |
3187 static void init_dequant_tables(H264Context *h){ | |
3188 int i,x; | |
3189 init_dequant4_coeff_table(h); | |
3190 if(h->pps.transform_8x8_mode) | |
3191 init_dequant8_coeff_table(h); | |
3192 if(h->sps.transform_bypass){ | |
3193 for(i=0; i<6; i++) | |
3194 for(x=0; x<16; x++) | |
3195 h->dequant4_coeff[i][0][x] = 1<<6; | |
3196 if(h->pps.transform_8x8_mode) | |
3197 for(i=0; i<2; i++) | |
3198 for(x=0; x<64; x++) | |
3199 h->dequant8_coeff[i][0][x] = 1<<6; | |
3200 } | |
3201 } | |
3202 | |
3203 | |
1168 | 3204 /** |
3205 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3206 * needs width/height |
1168 | 3207 */ |
3208 static int alloc_tables(H264Context *h){ | |
3209 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
|
3210 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 3211 int x,y; |
1168 | 3212 |
3213 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
|
3214 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3215 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 3216 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
|
3217 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
|
3218 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 3219 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 3220 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3221 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
|
3222 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
|
3223 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
|
3224 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 3225 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
|
3226 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3227 |
3316 | 3228 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
3229 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 3230 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
3231 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
|
3232 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 3233 for(y=0; y<s->mb_height; y++){ |
3234 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
|
3235 const int mb_xy= x + y*s->mb_stride; |
1168 | 3236 const int b_xy = 4*x + 4*y*h->b_stride; |
3237 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 3238 |
1168 | 3239 h->mb2b_xy [mb_xy]= b_xy; |
3240 h->mb2b8_xy[mb_xy]= b8_xy; | |
3241 } | |
3242 } | |
2415 | 3243 |
2417 | 3244 s->obmc_scratchpad = NULL; |
3245 | |
2920 | 3246 if(!h->dequant4_coeff[0]) |
3247 init_dequant_tables(h); | |
3248 | |
1168 | 3249 return 0; |
3250 fail: | |
3251 free_tables(h); | |
3252 return -1; | |
3253 } | |
3254 | |
3255 static void common_init(H264Context *h){ | |
3256 MpegEncContext * const s = &h->s; | |
3257 | |
3258 s->width = s->avctx->width; | |
3259 s->height = s->avctx->height; | |
3260 s->codec_id= s->avctx->codec->id; | |
2967 | 3261 |
1168 | 3262 init_pred_ptrs(h); |
3263 | |
2919 | 3264 h->dequant_coeff_pps= -1; |
1698 | 3265 s->unrestricted_mv=1; |
1168 | 3266 s->decode=1; //FIXME |
2920 | 3267 |
3268 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
3269 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 3270 } |
3271 | |
3272 static int decode_init(AVCodecContext *avctx){ | |
3273 H264Context *h= avctx->priv_data; | |
3274 MpegEncContext * const s = &h->s; | |
3275 | |
1892 | 3276 MPV_decode_defaults(s); |
2967 | 3277 |
1168 | 3278 s->avctx = avctx; |
3279 common_init(h); | |
3280 | |
3281 s->out_format = FMT_H264; | |
3282 s->workaround_bugs= avctx->workaround_bugs; | |
3283 | |
3284 // set defaults | |
3285 // s->decode_mb= ff_h263_decode_mb; | |
3286 s->low_delay= 1; | |
3287 avctx->pix_fmt= PIX_FMT_YUV420P; | |
3288 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3289 decode_init_vlc(); |
2967 | 3290 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3291 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
|
3292 *(char *)avctx->extradata == 1){ |
2227 | 3293 h->is_avc = 1; |
3294 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
|
3295 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3296 h->is_avc = 0; |
2227 | 3297 } |
3298 | |
1168 | 3299 return 0; |
3300 } | |
3301 | |
2935 | 3302 static int frame_start(H264Context *h){ |
1168 | 3303 MpegEncContext * const s = &h->s; |
3304 int i; | |
3305 | |
2935 | 3306 if(MPV_frame_start(s, s->avctx) < 0) |
3307 return -1; | |
1168 | 3308 ff_er_frame_start(s); |
3309 | |
3310 assert(s->linesize && s->uvlinesize); | |
3311 | |
3312 for(i=0; i<16; i++){ | |
3313 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
|
3314 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 3315 } |
3316 for(i=0; i<4; i++){ | |
3317 h->block_offset[16+i]= | |
3318 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
|
3319 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3320 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 3321 } |
3322 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
3323 /* 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
|
3324 * 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
|
3325 if(!s->obmc_scratchpad) |
3316 | 3326 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
3327 | |
3328 /* some macroblocks will be accessed before they're available */ | |
3329 if(FRAME_MBAFF) | |
3330 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
|
3331 |
1168 | 3332 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 3333 return 0; |
1168 | 3334 } |
3335 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3336 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
|
3337 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
|
3338 int i; |
2967 | 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 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
|
3341 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
|
3342 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
|
3343 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3344 // 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
|
3345 // 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
|
3346 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
|
3347 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
|
3348 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
|
3349 } |
2967 | 3350 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3351 *(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
|
3352 *(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
|
3353 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3354 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
|
3355 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
|
3356 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
|
3357 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
|
3358 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
|
3359 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
|
3360 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3361 *(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3362 *(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
|
3363 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3364 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3365 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3366 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
|
3367 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
|
3368 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
|
3369 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3370 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
|
3371 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
|
3372 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3373 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
|
3374 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
|
3375 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
|
3376 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3377 #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
|
3378 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3379 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3380 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3381 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3382 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3383 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3384 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
|
3385 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
|
3386 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3387 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3388 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3389 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3390 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
|
3391 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3392 if(s->mb_x+1 < s->mb_width){ |
2755 | 3393 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3394 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3395 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3396 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3397 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
|
3398 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3399 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
|
3400 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
|
3401 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
|
3402 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3403 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3404 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3405 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
|
3406 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
|
3407 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3408 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3409 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3410 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3411 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
|
3412 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3413 int i; |
2967 | 3414 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3415 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3416 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3417 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3418 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3419 // 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
|
3420 // 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
|
3421 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
|
3422 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
|
3423 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3424 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
|
3425 } |
2967 | 3426 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3427 *(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
|
3428 *(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
|
3429 *(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
|
3430 *(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
|
3431 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3432 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3433 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
|
3434 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
|
3435 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
|
3436 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
|
3437 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3438 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
|
3439 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
|
3440 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3441 *(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
|
3442 *(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
|
3443 *(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
|
3444 *(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
|
3445 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3446 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3447 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3448 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
|
3449 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3450 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3451 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3452 int deblock_left = (s->mb_x > 0); |
3316 | 3453 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
|
3454 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3455 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
|
3456 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3457 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3458 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3459 src_cr -= 2 * uvlinesize + 1; |
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 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3462 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3463 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3464 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3465 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3466 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3467 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3468 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
|
3469 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
|
3470 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3471 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3472 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3473 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3474 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
|
3475 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
|
3476 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
|
3477 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3478 if(s->mb_x+1 < s->mb_width){ |
3479 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3480 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3481 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3482 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3483 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3484 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3485 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3486 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
|
3487 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
|
3488 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
|
3489 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3490 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3491 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3492 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
|
3493 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
|
3494 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
|
3495 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
|
3496 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3497 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3498 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3499 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3500 static void av_always_inline hl_decode_mb_internal(H264Context *h, int simple){ |
1168 | 3501 MpegEncContext * const s = &h->s; |
3502 const int mb_x= s->mb_x; | |
3503 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
|
3504 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3505 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3506 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3507 int linesize, uvlinesize /*dct_offset*/; | |
3508 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3509 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
|
3510 const unsigned int bottom = mb_y & 1; |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3511 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass), is_h264 = (simple || s->codec_id == CODEC_ID_H264); |
2763 | 3512 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
|
3513 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3514 |
3515 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3516 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3517 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3518 | |
4000 | 3519 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3520 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3521 | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3522 if (!simple && MB_FIELD) { |
3316 | 3523 linesize = h->mb_linesize = s->linesize * 2; |
3524 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
|
3525 block_offset = &h->block_offset[24]; |
1168 | 3526 if(mb_y&1){ //FIXME move out of this func? |
3527 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3528 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3529 dest_cr-= s->uvlinesize*7; |
1168 | 3530 } |
3316 | 3531 if(FRAME_MBAFF) { |
3532 int list; | |
4533 | 3533 for(list=0; list<h->list_count; list++){ |
3316 | 3534 if(!USES_LIST(mb_type, list)) |
3535 continue; | |
3536 if(IS_16X16(mb_type)){ | |
3537 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3538 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3539 }else{ | |
3540 for(i=0; i<16; i+=4){ | |
3541 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3542 int ref = h->ref_cache[list][scan8[i]]; | |
3543 if(ref >= 0) | |
3544 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3545 } | |
3546 } | |
3547 } | |
3548 } | |
1168 | 3549 } else { |
3316 | 3550 linesize = h->mb_linesize = s->linesize; |
3551 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3552 // dct_offset = s->linesize * 16; |
3553 } | |
2967 | 3554 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3555 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3556 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3557 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
|
3558 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3559 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3560 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3561 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3562 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3563 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3564 } |
1168 | 3565 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3566 if(!simple && FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3316 | 3567 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ |
3568 int mbt_y = mb_y&~1; | |
3569 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3570 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3571 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3572 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3573 } | |
3574 | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3575 if (!simple && IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3576 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3577 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3578 // 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
|
3579 // 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
|
3580 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3581 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3582 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
|
3583 *(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
|
3584 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3585 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3586 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3587 for(i=16; i<16+4; 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_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
|
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=20; i<20+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_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
|
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 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3601 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3602 if(IS_INTRA(mb_type)){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3603 if(h->deblocking_filter && (simple || !FRAME_MBAFF)) |
3316 | 3604 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
|
3605 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3606 if(simple || !(s->flags&CODEC_FLAG_GRAY)){ |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3607 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
|
3608 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
|
3609 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3610 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3611 if(IS_INTRA4x4(mb_type)){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3612 if(simple || !s->encoding){ |
2755 | 3613 if(IS_8x8DCT(mb_type)){ |
3614 for(i=0; i<16; i+=4){ | |
3615 uint8_t * const ptr= dest_y + block_offset[i]; | |
3616 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
|
3617 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3618 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
4546 | 3619 (h->topright_samples_available<<i)&0x4000, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3620 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3621 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3622 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3623 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3624 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3625 } |
2755 | 3626 } |
3627 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3628 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
|
3629 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
|
3630 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3631 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
|
3632 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3633 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3634 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
|
3635 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
|
3636 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
|
3637 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3638 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3639 topright= (uint8_t*) &tr; |
2967 | 3640 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3641 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3642 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3643 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3644 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3645 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3646 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3647 if(nnz){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3648 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3649 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3650 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3651 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3652 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3653 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3654 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
|
3655 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3656 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3657 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3658 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3659 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3660 if(is_h264){ |
2763 | 3661 if(!transform_bypass) |
2919 | 3662 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3663 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3664 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
|
3665 } |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3666 if(h->deblocking_filter && (simple || !FRAME_MBAFF)) |
3316 | 3667 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3668 }else if(is_h264){ |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3669 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
|
3670 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
|
3671 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
|
3672 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
|
3673 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3674 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3675 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3676 if(!IS_INTRA4x4(mb_type)){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3677 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3678 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3679 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3680 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3681 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
|
3682 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3683 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
|
3684 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3685 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3686 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3687 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3688 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3689 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3690 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3691 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
|
3692 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3693 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
|
3694 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3695 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3696 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3697 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3698 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
|
3699 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
|
3700 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
|
3701 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3702 } |
1168 | 3703 } |
3704 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3705 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3706 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3707 if(simple || !(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3708 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3709 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3710 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3711 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3712 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3713 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3714 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]); |
3715 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 | 3716 } |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3717 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3718 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3719 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3720 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
|
3721 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3722 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
|
3723 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3724 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3725 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
|
3726 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
|
3727 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
|
3728 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
|
3729 } |
1250 | 3730 } |
1168 | 3731 } |
3732 } | |
3733 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3734 if(h->deblocking_filter) { |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3735 if (!simple && FRAME_MBAFF) { |
3316 | 3736 //FIXME try deblocking one mb at a time? |
3737 // 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
|
3738 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
|
3739 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
|
3740 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
|
3741 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
|
3742 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
|
3743 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3744 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
|
3745 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
|
3746 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
|
3747 |
3316 | 3748 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3749 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3750 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3751 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3752 // deblock a pair |
2967 | 3753 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3754 s->mb_y--; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3755 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
|
3756 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3757 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
|
3758 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
|
3759 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3760 s->mb_y++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3761 tprintf("call mbaff filter_mb\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3762 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3763 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
|
3764 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
|
3765 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3766 tprintf("call filter_mb\n"); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3767 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
|
3768 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
|
3769 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
|
3770 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3771 } |
1168 | 3772 } |
3773 | |
3774 /** | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3775 * Process a macroblock; this case avoids checks for expensive uncommon cases. |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3776 */ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3777 static void hl_decode_mb_simple(H264Context *h){ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3778 hl_decode_mb_internal(h, 1); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3779 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3780 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3781 /** |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3782 * Process a macroblock; this handles edge cases, such as interlacing. |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3783 */ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3784 static void av_noinline hl_decode_mb_complex(H264Context *h){ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3785 hl_decode_mb_internal(h, 0); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3786 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3787 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3788 static void hl_decode_mb(H264Context *h){ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3789 MpegEncContext * const s = &h->s; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3790 const int mb_x= s->mb_x; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3791 const int mb_y= s->mb_y; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3792 const int mb_xy= mb_x + mb_y*s->mb_stride; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3793 const int mb_type= s->current_picture.mb_type[mb_xy]; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3794 int is_complex = FRAME_MBAFF || MB_FIELD || IS_INTRA_PCM(mb_type) || s->codec_id != CODEC_ID_H264 || (s->flags&CODEC_FLAG_GRAY) || s->encoding; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3795 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3796 if(!s->decode) |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3797 return; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3798 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3799 if (is_complex) |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3800 hl_decode_mb_complex(h); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3801 else hl_decode_mb_simple(h); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3802 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3803 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3804 /** |
1168 | 3805 * fills the default_ref_list. |
3806 */ | |
3807 static int fill_default_ref_list(H264Context *h){ | |
3808 MpegEncContext * const s = &h->s; | |
3809 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
|
3810 int smallest_poc_greater_than_current = -1; |
2582 | 3811 Picture sorted_short_ref[32]; |
2967 | 3812 |
1168 | 3813 if(h->slice_type==B_TYPE){ |
3814 int out_i; | |
2713 | 3815 int limit= INT_MIN; |
1168 | 3816 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3817 /* sort frame according to poc in B slice */ |
1168 | 3818 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3819 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
|
3820 int best_poc=INT_MAX; |
1168 | 3821 |
3822 for(i=0; i<h->short_ref_count; i++){ | |
3823 const int poc= h->short_ref[i]->poc; | |
3824 if(poc > limit && poc < best_poc){ | |
3825 best_poc= poc; | |
3826 best_i= i; | |
3827 } | |
3828 } | |
2967 | 3829 |
2713 | 3830 assert(best_i != INT_MIN); |
2967 | 3831 |
1168 | 3832 limit= best_poc; |
3833 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
|
3834 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
|
3835 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
|
3836 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
|
3837 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
|
3838 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3839 } |
1168 | 3840 } |
3841 } | |
3842 | |
3843 if(s->picture_structure == PICT_FRAME){ | |
3844 if(h->slice_type==B_TYPE){ | |
3845 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
|
3846 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
|
3847 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3848 // find the largest poc |
1168 | 3849 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
|
3850 int index = 0; |
2447 | 3851 int j= -99; |
3852 int step= list ? -1 : 1; | |
3853 | |
3854 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3855 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
|
3856 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3857 return -1; |
2447 | 3858 step = -step; |
3859 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
|
3860 } |
2447 | 3861 if(sorted_short_ref[j].reference != 3) continue; |
3862 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3863 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3864 } |
3865 | |
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
|
3866 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
|
3867 if(h->long_ref[i] == NULL) continue; |
1168 | 3868 if(h->long_ref[i]->reference != 3) continue; |
3869 | |
3870 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3871 h->default_ref_list[ list ][index++].pic_id= i;; | |
3872 } | |
2967 | 3873 |
2447 | 3874 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
|
3875 // 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
|
3876 // L0 and L1 are identical |
1168 | 3877 Picture temp= h->default_ref_list[1][0]; |
3878 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3879 h->default_ref_list[1][1] = temp; |
1168 | 3880 } |
3881 | |
3882 if(index < h->ref_count[ list ]) | |
3883 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3884 } | |
3885 }else{ | |
3886 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3887 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3888 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3889 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3890 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3891 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3892 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
|
3893 if(h->long_ref[i] == NULL) continue; |
1168 | 3894 if(h->long_ref[i]->reference != 3) continue; |
3895 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3896 h->default_ref_list[0][index++].pic_id= i;; | |
3897 } | |
3898 if(index < h->ref_count[0]) | |
3899 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3900 } | |
3901 }else{ //FIELD | |
3902 if(h->slice_type==B_TYPE){ | |
3903 }else{ | |
3904 //FIXME second field balh | |
3905 } | |
3906 } | |
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
|
3907 #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
|
3908 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
|
3909 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
|
3910 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3911 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
|
3912 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
|
3913 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
|
3914 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3915 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3916 #endif |
1168 | 3917 return 0; |
3918 } | |
3919 | |
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
|
3920 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
|
3921 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
|
3922 |
1168 | 3923 static int decode_ref_pic_list_reordering(H264Context *h){ |
3924 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3925 int list, index; |
2967 | 3926 |
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
|
3927 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
|
3928 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3929 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 3930 |
4533 | 3931 for(list=0; list<h->list_count; list++){ |
1168 | 3932 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); |
3933 | |
3934 if(get_bits1(&s->gb)){ | |
3935 int pred= h->curr_pic_num; | |
3936 | |
3937 for(index=0; ; index++){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3938 unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3939 unsigned int pic_id; |
1168 | 3940 int i; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3941 Picture *ref = NULL; |
2967 | 3942 |
3943 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
|
3944 break; |
2967 | 3945 |
1168 | 3946 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3947 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3948 return -1; |
3949 } | |
2967 | 3950 |
1168 | 3951 if(reordering_of_pic_nums_idc<3){ |
3952 if(reordering_of_pic_nums_idc<2){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3953 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; |
1168 | 3954 |
3955 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
|
3956 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3957 return -1; |
3958 } | |
3959 | |
3960 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3961 else pred+= abs_diff_pic_num; | |
3962 pred &= h->max_pic_num - 1; | |
2967 | 3963 |
2683 | 3964 for(i= h->short_ref_count-1; i>=0; i--){ |
3965 ref = h->short_ref[i]; | |
3966 assert(ref->reference == 3); | |
3967 assert(!ref->long_ref); | |
3968 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 3969 break; |
3970 } | |
2683 | 3971 if(i>=0) |
3972 ref->pic_id= ref->frame_num; | |
1168 | 3973 }else{ |
3974 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3975 if(pic_id>31){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3976 av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3977 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3978 } |
2683 | 3979 ref = h->long_ref[pic_id]; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3980 if(ref){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3981 ref->pic_id= pic_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3982 assert(ref->reference == 3); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3983 assert(ref->long_ref); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3984 i=0; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3985 }else{ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3986 i=-1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3987 } |
1168 | 3988 } |
3989 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3990 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3991 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3992 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 3993 } else { |
3994 for(i=index; i+1<h->ref_count[list]; i++){ | |
3995 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
3996 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
|
3997 } |
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
|
3998 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
|
3999 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
|
4000 } |
2683 | 4001 h->ref_list[list][index]= *ref; |
1168 | 4002 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
4003 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4004 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 4005 return -1; |
4006 } | |
4007 } | |
4008 } | |
4533 | 4009 } |
4010 for(list=0; list<h->list_count; list++){ | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4011 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
|
4012 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4013 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4014 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4015 } |
2967 | 4016 |
2396 | 4017 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
4018 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
4019 direct_ref_list_init(h); |
2967 | 4020 return 0; |
1168 | 4021 } |
4022 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
4023 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 4024 int list, i, j; |
4533 | 4025 for(list=0; list<2; list++){ //FIXME try list_count |
3316 | 4026 for(i=0; i<h->ref_count[list]; i++){ |
4027 Picture *frame = &h->ref_list[list][i]; | |
4028 Picture *field = &h->ref_list[list][16+2*i]; | |
4029 field[0] = *frame; | |
4030 for(j=0; j<3; j++) | |
4031 field[0].linesize[j] <<= 1; | |
4032 field[1] = field[0]; | |
4033 for(j=0; j<3; j++) | |
4034 field[1].data[j] += frame->linesize[j]; | |
4035 | |
4036 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4037 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4038 for(j=0; j<2; j++){ | |
4039 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4040 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4041 } | |
4042 } | |
4043 } | |
4044 for(j=0; j<h->ref_count[1]; j++){ | |
4045 for(i=0; i<h->ref_count[0]; i++) | |
4046 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4047 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4048 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4049 } | |
4050 } | |
4051 | |
1168 | 4052 static int pred_weight_table(H264Context *h){ |
4053 MpegEncContext * const s = &h->s; | |
4054 int list, i; | |
2415 | 4055 int luma_def, chroma_def; |
2967 | 4056 |
2415 | 4057 h->use_weight= 0; |
4058 h->use_weight_chroma= 0; | |
1168 | 4059 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4060 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4061 luma_def = 1<<h->luma_log2_weight_denom; |
4062 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4063 |
4064 for(list=0; list<2; list++){ | |
4065 for(i=0; i<h->ref_count[list]; i++){ | |
4066 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4067 |
1168 | 4068 luma_weight_flag= get_bits1(&s->gb); |
4069 if(luma_weight_flag){ | |
4070 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4071 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4072 if( h->luma_weight[list][i] != luma_def |
4073 || h->luma_offset[list][i] != 0) | |
4074 h->use_weight= 1; | |
4075 }else{ | |
4076 h->luma_weight[list][i]= luma_def; | |
4077 h->luma_offset[list][i]= 0; | |
1168 | 4078 } |
4079 | |
4080 chroma_weight_flag= get_bits1(&s->gb); | |
4081 if(chroma_weight_flag){ | |
4082 int j; | |
4083 for(j=0; j<2; j++){ | |
4084 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4085 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4086 if( h->chroma_weight[list][i][j] != chroma_def |
4087 || h->chroma_offset[list][i][j] != 0) | |
4088 h->use_weight_chroma= 1; | |
4089 } | |
4090 }else{ | |
4091 int j; | |
4092 for(j=0; j<2; j++){ | |
4093 h->chroma_weight[list][i][j]= chroma_def; | |
4094 h->chroma_offset[list][i][j]= 0; | |
1168 | 4095 } |
4096 } | |
4097 } | |
4098 if(h->slice_type != B_TYPE) break; | |
4099 } | |
2415 | 4100 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4101 return 0; |
4102 } | |
4103 | |
2415 | 4104 static void implicit_weight_table(H264Context *h){ |
4105 MpegEncContext * const s = &h->s; | |
4106 int ref0, ref1; | |
4107 int cur_poc = s->current_picture_ptr->poc; | |
4108 | |
4109 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4110 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4111 h->use_weight= 0; | |
4112 h->use_weight_chroma= 0; | |
4113 return; | |
4114 } | |
4115 | |
4116 h->use_weight= 2; | |
4117 h->use_weight_chroma= 2; | |
4118 h->luma_log2_weight_denom= 5; | |
4119 h->chroma_log2_weight_denom= 5; | |
4120 | |
4121 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4122 int poc0 = h->ref_list[0][ref0].poc; | |
4123 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4124 int poc1 = h->ref_list[1][ref1].poc; |
4594 | 4125 int td = av_clip(poc1 - poc0, -128, 127); |
2415 | 4126 if(td){ |
4594 | 4127 int tb = av_clip(cur_poc - poc0, -128, 127); |
4001 | 4128 int tx = (16384 + (FFABS(td) >> 1)) / td; |
4594 | 4129 int dist_scale_factor = av_clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
2415 | 4130 if(dist_scale_factor < -64 || dist_scale_factor > 128) |
4131 h->implicit_weight[ref0][ref1] = 32; | |
4132 else | |
4133 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4134 }else | |
4135 h->implicit_weight[ref0][ref1] = 32; | |
4136 } | |
4137 } | |
4138 } | |
4139 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4140 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
|
4141 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4142 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4143 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
|
4144 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4145 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4146 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
|
4147 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
|
4148 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4149 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4150 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4151 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4152 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4153 |
1168 | 4154 /** |
2392 | 4155 * instantaneous decoder refresh. |
1168 | 4156 */ |
4157 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
|
4158 int i; |
1168 | 4159 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4160 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4161 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
|
4162 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
|
4163 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4164 } |
1168 | 4165 } |
4166 h->long_ref_count=0; | |
4167 | |
4168 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
|
4169 unreference_pic(h, h->short_ref[i]); |
1168 | 4170 h->short_ref[i]= NULL; |
4171 } | |
4172 h->short_ref_count=0; | |
4173 } | |
4174 | |
2640 | 4175 /* forget old pics after a seek */ |
4176 static void flush_dpb(AVCodecContext *avctx){ | |
4177 H264Context *h= avctx->priv_data; | |
4178 int i; | |
3144 | 4179 for(i=0; i<16; i++) { |
4180 if(h->delayed_pic[i]) | |
4181 h->delayed_pic[i]->reference= 0; | |
2640 | 4182 h->delayed_pic[i]= NULL; |
3144 | 4183 } |
4184 if(h->delayed_output_pic) | |
4185 h->delayed_output_pic->reference= 0; | |
2640 | 4186 h->delayed_output_pic= NULL; |
4187 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4188 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4189 h->s.current_picture_ptr->reference= 0; |
2640 | 4190 } |
4191 | |
1168 | 4192 /** |
4193 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4194 * @return the removed picture or NULL if an error occurs |
1168 | 4195 */ |
4196 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4197 MpegEncContext * const s = &h->s; |
1168 | 4198 int i; |
2967 | 4199 |
1169 | 4200 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
|
4201 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4202 |
1168 | 4203 for(i=0; i<h->short_ref_count; i++){ |
4204 Picture *pic= h->short_ref[i]; | |
1169 | 4205 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
|
4206 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4207 if(pic->frame_num == frame_num){ |
4208 h->short_ref[i]= NULL; | |
4209 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4210 h->short_ref_count--; | |
4211 return pic; | |
4212 } | |
4213 } | |
4214 return NULL; | |
4215 } | |
4216 | |
4217 /** | |
4218 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4219 * @return the removed picture or NULL if an error occurs |
1168 | 4220 */ |
4221 static Picture * remove_long(H264Context *h, int i){ | |
4222 Picture *pic; | |
4223 | |
4224 pic= h->long_ref[i]; | |
4225 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
|
4226 if(pic) h->long_ref_count--; |
1168 | 4227 |
4228 return pic; | |
4229 } | |
4230 | |
4231 /** | |
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
|
4232 * 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
|
4233 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4234 static void print_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
|
4235 uint32_t i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4236 if(h->s.avctx->debug&FF_DEBUG_MMCO) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4237 av_log(h->s.avctx, AV_LOG_DEBUG, "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
|
4238 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
|
4239 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
|
4240 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
|
4241 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4242 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4243 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4244 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4245 /** |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4246 * 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
|
4247 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4248 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
|
4249 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
|
4250 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
|
4251 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
|
4252 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
|
4253 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
|
4254 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
|
4255 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
|
4256 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4257 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4258 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4259 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4260 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4261 /** |
1168 | 4262 * Executes the reference picture marking (memory management control operations). |
4263 */ | |
4264 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4265 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
|
4266 int i, j; |
1168 | 4267 int current_is_long=0; |
4268 Picture *pic; | |
2967 | 4269 |
1168 | 4270 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
|
4271 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4272 |
1168 | 4273 for(i=0; i<mmco_count; i++){ |
4274 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
|
4275 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 | 4276 |
4277 switch(mmco[i].opcode){ | |
4278 case MMCO_SHORT2UNUSED: | |
4279 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
|
4280 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4281 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4282 else if(s->avctx->debug&FF_DEBUG_MMCO) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4283 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4284 break; |
4285 case MMCO_SHORT2LONG: | |
4286 pic= remove_long(h, mmco[i].long_index); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4287 if(pic) unreference_pic(h, pic); |
2967 | 4288 |
1168 | 4289 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4290 if (h->long_ref[ mmco[i].long_index ]){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4291 h->long_ref[ mmco[i].long_index ]->long_ref=1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4292 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4293 } |
1168 | 4294 break; |
4295 case MMCO_LONG2UNUSED: | |
4296 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
|
4297 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4298 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4299 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
|
4300 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4301 break; |
4302 case MMCO_LONG: | |
4303 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
|
4304 if(pic) unreference_pic(h, pic); |
2967 | 4305 |
1168 | 4306 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4307 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4308 h->long_ref_count++; | |
2967 | 4309 |
1168 | 4310 current_is_long=1; |
4311 break; | |
4312 case MMCO_SET_MAX_LONG: | |
4313 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
|
4314 // 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
|
4315 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
|
4316 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
|
4317 if (pic) unreference_pic(h, pic); |
1168 | 4318 } |
4319 break; | |
4320 case MMCO_RESET: | |
4321 while(h->short_ref_count){ | |
4322 pic= remove_short(h, h->short_ref[0]->frame_num); | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4323 if(pic) unreference_pic(h, pic); |
1168 | 4324 } |
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
|
4325 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
|
4326 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
|
4327 if(pic) unreference_pic(h, pic); |
1168 | 4328 } |
4329 break; | |
4330 default: assert(0); | |
4331 } | |
4332 } | |
2967 | 4333 |
1168 | 4334 if(!current_is_long){ |
4335 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4336 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4337 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4338 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4339 } |
2967 | 4340 |
1168 | 4341 if(h->short_ref_count) |
1169 | 4342 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4343 | |
4344 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4345 h->short_ref[0]->long_ref=0; |
4346 h->short_ref_count++; | |
4347 } | |
2967 | 4348 |
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
|
4349 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
|
4350 print_long_term(h); |
2967 | 4351 return 0; |
1168 | 4352 } |
4353 | |
4354 static int decode_ref_pic_marking(H264Context *h){ | |
4355 MpegEncContext * const s = &h->s; | |
4356 int i; | |
2967 | 4357 |
1168 | 4358 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4359 s->broken_link= get_bits1(&s->gb) -1; | |
4360 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4361 if(h->mmco[0].long_index == -1) | |
4362 h->mmco_index= 0; | |
4363 else{ | |
4364 h->mmco[0].opcode= MMCO_LONG; | |
4365 h->mmco_index= 1; | |
2967 | 4366 } |
1168 | 4367 }else{ |
4368 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4369 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4370 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4371 | |
4372 h->mmco[i].opcode= opcode; | |
4373 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4374 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 | |
4375 /* 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
|
4376 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4377 return -1; |
4378 }*/ | |
4379 } | |
4380 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4381 unsigned int long_index= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4382 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ long_index >= 16){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4383 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4384 return -1; |
4385 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4386 h->mmco[i].long_index= long_index; |
1168 | 4387 } |
2967 | 4388 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4389 if(opcode > (unsigned)MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4390 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4391 return -1; |
4392 } | |
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
|
4393 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
|
4394 break; |
1168 | 4395 } |
4396 h->mmco_index= i; | |
4397 }else{ | |
4398 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4399 | |
4400 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4401 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4402 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4403 h->mmco_index= 1; | |
4404 }else | |
4405 h->mmco_index= 0; | |
4406 } | |
4407 } | |
2967 | 4408 |
4409 return 0; | |
1168 | 4410 } |
4411 | |
4412 static int init_poc(H264Context *h){ | |
4413 MpegEncContext * const s = &h->s; | |
4414 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4415 int field_poc[2]; | |
4416 | |
4417 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4418 h->frame_num_offset= 0; | |
4419 }else{ | |
4420 if(h->frame_num < h->prev_frame_num) | |
4421 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4422 else | |
4423 h->frame_num_offset= h->prev_frame_num_offset; | |
4424 } | |
4425 | |
4426 if(h->sps.poc_type==0){ | |
4427 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4428 | |
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
|
4429 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
|
4430 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
|
4431 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
|
4432 } |
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
|
4433 |
1168 | 4434 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4435 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4436 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4437 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4438 else | |
4439 h->poc_msb = h->prev_poc_msb; | |
4440 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4441 field_poc[0] = |
1168 | 4442 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4443 if(s->picture_structure == PICT_FRAME) |
1168 | 4444 field_poc[1] += h->delta_poc_bottom; |
4445 }else if(h->sps.poc_type==1){ | |
4446 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4447 int i; | |
4448 | |
4449 if(h->sps.poc_cycle_length != 0) | |
4450 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4451 else | |
4452 abs_frame_num = 0; | |
4453 | |
4454 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4455 abs_frame_num--; | |
2967 | 4456 |
1168 | 4457 expected_delta_per_poc_cycle = 0; |
4458 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4459 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4460 | |
4461 if(abs_frame_num > 0){ | |
4462 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4463 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4464 | |
4465 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4466 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4467 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4468 } else | |
4469 expectedpoc = 0; | |
4470 | |
2967 | 4471 if(h->nal_ref_idc == 0) |
1168 | 4472 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4473 |
1168 | 4474 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4475 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4476 | |
4477 if(s->picture_structure == PICT_FRAME) | |
4478 field_poc[1] += h->delta_poc[1]; | |
4479 }else{ | |
4480 int poc; | |
4481 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4482 poc= 0; | |
4483 }else{ | |
4484 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4485 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4486 } | |
4487 field_poc[0]= poc; | |
4488 field_poc[1]= poc; | |
4489 } | |
2967 | 4490 |
1168 | 4491 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4492 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4493 if(s->picture_structure != PICT_TOP_FIELD) | |
4494 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4495 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4496 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4497 | |
4498 return 0; | |
4499 } | |
4500 | |
4501 /** | |
4502 * decodes a slice header. | |
4503 * this will allso call MPV_common_init() and frame_start() as needed | |
4504 */ | |
4505 static int decode_slice_header(H264Context *h){ | |
4506 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4507 unsigned int first_mb_in_slice; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4508 unsigned int pps_id; |
1168 | 4509 int num_ref_idx_active_override_flag; |
4510 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4511 unsigned int slice_type, tmp; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4512 int default_ref_list_done = 0; |
1168 | 4513 |
4514 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
|
4515 s->dropable= h->nal_ref_idc == 0; |
1168 | 4516 |
4517 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4518 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4519 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
|
4520 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4521 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 | 4522 return -1; |
1168 | 4523 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4524 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4525 slice_type -= 5; |
1168 | 4526 h->slice_type_fixed=1; |
4527 }else | |
4528 h->slice_type_fixed=0; | |
2967 | 4529 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4530 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
|
4531 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
|
4532 || (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
|
4533 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
|
4534 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4535 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
|
4536 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4537 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4538 |
1168 | 4539 pps_id= get_ue_golomb(&s->gb); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4540 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4541 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4542 return -1; |
4543 } | |
4544 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4545 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
|
4546 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4547 return -1; |
4548 } | |
4549 | |
1168 | 4550 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4551 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
|
4552 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4553 return -1; |
4554 } | |
2919 | 4555 |
4363 | 4556 if(h->dequant_coeff_pps != pps_id){ |
4557 h->dequant_coeff_pps = pps_id; | |
2919 | 4558 init_dequant_tables(h); |
4559 } | |
2967 | 4560 |
1168 | 4561 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
|
4562 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4563 |
3178 | 4564 h->b_stride= s->mb_width*4; |
4565 h->b8_stride= s->mb_width*2; | |
1168 | 4566 |
1371 | 4567 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4568 if(h->sps.frame_mbs_only_flag) |
1371 | 4569 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4570 else |
1371 | 4571 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4572 |
4573 if (s->context_initialized | |
1548 | 4574 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4575 free_tables(h); |
4576 MPV_common_end(s); | |
4577 } | |
4578 if (!s->context_initialized) { | |
4579 if (MPV_common_init(s) < 0) | |
4580 return -1; | |
2967 | 4581 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4582 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
|
4583 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
|
4584 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
|
4585 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4586 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4587 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4588 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4589 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4590 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4591 #undef T |
4592 } | |
4593 } | |
4594 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4595 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4596 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4597 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4598 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4599 }else{ |
4600 int i; | |
4601 for(i=0; i<64; i++){ | |
4602 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4603 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4604 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4605 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4606 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4607 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4608 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4609 } |
2763 | 4610 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4611 h->zigzag_scan_q0 = zigzag_scan; |
4612 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4613 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4614 h->field_scan_q0 = field_scan; |
4615 h->field_scan8x8_q0 = field_scan8x8; | |
4616 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4617 }else{ |
3316 | 4618 h->zigzag_scan_q0 = h->zigzag_scan; |
4619 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4620 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4621 h->field_scan_q0 = h->field_scan; |
4622 h->field_scan8x8_q0 = h->field_scan8x8; | |
4623 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4624 } |
1168 | 4625 |
4626 alloc_tables(h); | |
4627 | |
4628 s->avctx->width = s->width; | |
4629 s->avctx->height = s->height; | |
1548 | 4630 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4631 if(!s->avctx->sample_aspect_ratio.den) |
4632 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
|
4633 |
2648 | 4634 if(h->sps.timing_info_present_flag){ |
3052 | 4635 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
|
4636 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
|
4637 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4638 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
|
4639 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
|
4640 } |
1168 | 4641 } |
4642 | |
2392 | 4643 if(h->slice_num == 0){ |
2935 | 4644 if(frame_start(h) < 0) |
4645 return -1; | |
1168 | 4646 } |
4647 | |
1169 | 4648 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4649 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4650 | |
3316 | 4651 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4652 h->mb_aff_frame = 0; |
1168 | 4653 if(h->sps.frame_mbs_only_flag){ |
4654 s->picture_structure= PICT_FRAME; | |
4655 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4656 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4657 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4658 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
|
4659 } else { |
1168 | 4660 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4661 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
|
4662 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4663 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4664 assert(s->mb_num == s->mb_width * s->mb_height); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4665 if(first_mb_in_slice << h->mb_aff_frame >= s->mb_num || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4666 first_mb_in_slice >= s->mb_num){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4667 av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4668 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4669 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4670 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4671 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4672 assert(s->mb_y < s->mb_height); |
2967 | 4673 |
1168 | 4674 if(s->picture_structure==PICT_FRAME){ |
4675 h->curr_pic_num= h->frame_num; | |
4676 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4677 }else{ | |
4678 h->curr_pic_num= 2*h->frame_num; | |
4679 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4680 } | |
2967 | 4681 |
1168 | 4682 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4683 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4684 } |
2967 | 4685 |
1168 | 4686 if(h->sps.poc_type==0){ |
4687 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4688 |
1168 | 4689 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4690 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4691 } | |
4692 } | |
2967 | 4693 |
1168 | 4694 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4695 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4696 |
1168 | 4697 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4698 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4699 } | |
2967 | 4700 |
1168 | 4701 init_poc(h); |
2967 | 4702 |
1168 | 4703 if(h->pps.redundant_pic_cnt_present){ |
4704 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4705 } | |
4706 | |
4707 //set defaults, might be overriden a few line later | |
4708 h->ref_count[0]= h->pps.ref_count[0]; | |
4709 h->ref_count[1]= h->pps.ref_count[1]; | |
4710 | |
4711 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4712 if(h->slice_type == B_TYPE){ | |
4713 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4714 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4715 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4716 } |
4717 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4718 |
1168 | 4719 if(num_ref_idx_active_override_flag){ |
4720 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4721 if(h->slice_type==B_TYPE) | |
4722 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4723 | |
4532 | 4724 if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4725 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4726 h->ref_count[0]= h->ref_count[1]= 1; |
1168 | 4727 return -1; |
4728 } | |
4729 } | |
4532 | 4730 if(h->slice_type == B_TYPE) |
4731 h->list_count= 2; | |
4732 else | |
4733 h->list_count= 1; | |
4734 }else | |
4735 h->list_count= 0; | |
1168 | 4736 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4737 if(!default_ref_list_done){ |
1168 | 4738 fill_default_ref_list(h); |
4739 } | |
4740 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4741 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
|
4742 return -1; |
1168 | 4743 |
2967 | 4744 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4745 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4746 pred_weight_table(h); | |
2415 | 4747 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4748 implicit_weight_table(h); | |
4749 else | |
4750 h->use_weight = 0; | |
2967 | 4751 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4752 if(s->current_picture.reference) |
1168 | 4753 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
|
4754 |
3316 | 4755 if(FRAME_MBAFF) |
4756 fill_mbaff_ref_list(h); | |
4757 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4758 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac ){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4759 tmp = get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4760 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4761 av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4762 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4763 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4764 h->cabac_init_idc= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4765 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4766 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4767 h->last_qscale_diff = 0; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4768 tmp = h->pps.init_qp + get_se_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4769 if(tmp>51){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4770 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); |
1898 | 4771 return -1; |
4772 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4773 s->qscale= tmp; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4774 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4775 //FIXME qscale / qp ... stuff |
4776 if(h->slice_type == SP_TYPE){ | |
1453 | 4777 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4778 } |
4779 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4780 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4781 } |
4782 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4783 h->deblocking_filter = 1; |
1898 | 4784 h->slice_alpha_c0_offset = 0; |
4785 h->slice_beta_offset = 0; | |
1168 | 4786 if( h->pps.deblocking_filter_parameters_present ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4787 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4788 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4789 av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4790 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4791 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4792 h->deblocking_filter= tmp; |
2967 | 4793 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
|
4794 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
|
4795 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4796 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
|
4797 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
|
4798 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4799 } |
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
|
4800 } |
2792 | 4801 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4802 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4803 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4804 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4805 h->deblocking_filter= 0; | |
1168 | 4806 |
4807 #if 0 //FMO | |
4808 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4809 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4810 #endif | |
4811 | |
2392 | 4812 h->slice_num++; |
4813 | |
3316 | 4814 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4815 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4816 | |
1168 | 4817 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4818 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n", |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4819 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4820 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4821 first_mb_in_slice, |
1264 | 4822 av_get_pict_type_char(h->slice_type), |
1168 | 4823 pps_id, h->frame_num, |
4824 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4825 h->ref_count[0], h->ref_count[1], | |
4826 s->qscale, | |
2583 | 4827 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4828 h->use_weight, |
4829 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4830 ); |
4831 } | |
4832 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4833 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
|
4834 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
|
4835 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
|
4836 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4837 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
|
4838 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
|
4839 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4840 |
1168 | 4841 return 0; |
4842 } | |
4843 | |
4844 /** | |
4845 * | |
4846 */ | |
4847 static inline int get_level_prefix(GetBitContext *gb){ | |
4848 unsigned int buf; | |
4849 int log; | |
2967 | 4850 |
1168 | 4851 OPEN_READER(re, gb); |
4852 UPDATE_CACHE(re, gb); | |
4853 buf=GET_CACHE(re, gb); | |
2967 | 4854 |
1168 | 4855 log= 32 - av_log2(buf); |
4856 #ifdef TRACE | |
4857 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
|
4858 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 | 4859 #endif |
4860 | |
4861 LAST_SKIP_BITS(re, gb, log); | |
4862 CLOSE_READER(re, gb); | |
4863 | |
4864 return log-1; | |
4865 } | |
4866 | |
2755 | 4867 static inline int get_dct8x8_allowed(H264Context *h){ |
4868 int i; | |
4869 for(i=0; i<4; i++){ | |
4870 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
|
4871 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4872 return 0; |
4873 } | |
4874 return 1; | |
4875 } | |
4876 | |
1168 | 4877 /** |
4878 * decodes a residual block. | |
4879 * @param n block index | |
4880 * @param scantable scantable | |
4881 * @param max_coeff number of coefficients in the block | |
4882 * @return <0 if an error occured | |
4883 */ | |
2919 | 4884 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4885 MpegEncContext * const s = &h->s; |
4886 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 | 4887 int level[16]; |
4888 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4889 |
4890 //FIXME put trailing_onex into the context | |
4891 | |
4892 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4893 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4894 total_coeff= coeff_token>>2; | |
2967 | 4895 }else{ |
1168 | 4896 if(n == LUMA_DC_BLOCK_INDEX){ |
4897 total_coeff= pred_non_zero_count(h, 0); | |
4898 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4899 total_coeff= coeff_token>>2; | |
4900 }else{ | |
4901 total_coeff= pred_non_zero_count(h, n); | |
4902 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4903 total_coeff= coeff_token>>2; | |
4904 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4905 } | |
4906 } | |
4907 | |
4908 //FIXME set last_non_zero? | |
4909 | |
4910 if(total_coeff==0) | |
4911 return 0; | |
4391
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4912 if(total_coeff > (unsigned)max_coeff) { |
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4913 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff); |
4270 | 4914 return -1; |
4915 } | |
2967 | 4916 |
1168 | 4917 trailing_ones= coeff_token&3; |
1170 | 4918 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4919 assert(total_coeff<=16); |
2967 | 4920 |
1168 | 4921 for(i=0; i<trailing_ones; i++){ |
4922 level[i]= 1 - 2*get_bits1(gb); | |
4923 } | |
4924 | |
2897 | 4925 if(i<total_coeff) { |
1168 | 4926 int level_code, mask; |
2897 | 4927 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4928 int prefix= get_level_prefix(gb); | |
4929 | |
4930 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4931 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4932 if(suffix_length) | |
4933 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4934 else | |
4935 level_code= (prefix<<suffix_length); //part | |
4936 }else if(prefix==14){ | |
4937 if(suffix_length) | |
4938 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4939 else | |
4940 level_code= prefix + get_bits(gb, 4); //part | |
4941 }else if(prefix==15){ | |
4942 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
|
4943 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4944 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4945 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4946 return -1; |
4947 } | |
4948 | |
2897 | 4949 if(trailing_ones < 3) level_code += 2; |
4950 | |
4951 suffix_length = 1; | |
4952 if(level_code > 5) | |
4953 suffix_length++; | |
1168 | 4954 mask= -(level_code&1); |
4955 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4956 i++; |
4957 | |
4958 //remaining coefficients have suffix_length > 0 | |
4959 for(;i<total_coeff;i++) { | |
4960 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4961 prefix = get_level_prefix(gb); | |
4962 if(prefix<15){ | |
4963 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4964 }else if(prefix==15){ | |
4965 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4966 }else{ | |
4967 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4968 return -1; | |
4969 } | |
4970 mask= -(level_code&1); | |
4971 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4972 if(level_code > suffix_limit[suffix_length]) | |
4973 suffix_length++; | |
4974 } | |
1168 | 4975 } |
4976 | |
4977 if(total_coeff == max_coeff) | |
4978 zeros_left=0; | |
4979 else{ | |
4980 if(n == CHROMA_DC_BLOCK_INDEX) | |
4981 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4982 else | |
4983 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4984 } | |
2897 | 4985 |
4986 coeff_num = zeros_left + total_coeff - 1; | |
4987 j = scantable[coeff_num]; | |
4988 if(n > 24){ | |
4989 block[j] = level[0]; | |
4990 for(i=1;i<total_coeff;i++) { | |
4991 if(zeros_left <= 0) | |
4992 run_before = 0; | |
4993 else if(zeros_left < 7){ | |
4994 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4995 }else{ | |
4996 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4997 } | |
4998 zeros_left -= run_before; | |
4999 coeff_num -= 1 + run_before; | |
5000 j= scantable[ coeff_num ]; | |
5001 | |
5002 block[j]= level[i]; | |
5003 } | |
5004 }else{ | |
2919 | 5005 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 5006 for(i=1;i<total_coeff;i++) { |
5007 if(zeros_left <= 0) | |
5008 run_before = 0; | |
5009 else if(zeros_left < 7){ | |
5010 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
5011 }else{ | |
5012 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
5013 } | |
5014 zeros_left -= run_before; | |
5015 coeff_num -= 1 + run_before; | |
5016 j= scantable[ coeff_num ]; | |
5017 | |
2919 | 5018 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 5019 } |
1168 | 5020 } |
5021 | |
5022 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5023 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 5024 return -1; |
5025 } | |
2897 | 5026 |
1168 | 5027 return 0; |
5028 } | |
5029 | |
3316 | 5030 static void predict_field_decoding_flag(H264Context *h){ |
5031 MpegEncContext * const s = &h->s; | |
5032 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
5033 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
5034 ? s->current_picture.mb_type[mb_xy-1] | |
5035 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
5036 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
5037 : 0; | |
5038 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
5039 } | |
5040 | |
1168 | 5041 /** |
2396 | 5042 * decodes a P_SKIP or B_SKIP macroblock |
5043 */ | |
5044 static void decode_mb_skip(H264Context *h){ | |
5045 MpegEncContext * const s = &h->s; | |
5046 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
|
5047 int mb_type=0; |
2967 | 5048 |
2396 | 5049 memset(h->non_zero_count[mb_xy], 0, 16); |
5050 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
5051 | |
3316 | 5052 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5053 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5054 |
2396 | 5055 if( h->slice_type == B_TYPE ) |
5056 { | |
5057 // 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
|
5058 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5059 |
2449 | 5060 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5061 pred_direct_motion(h, &mb_type); |
3927 | 5062 mb_type|= MB_TYPE_SKIP; |
2396 | 5063 } |
5064 else | |
5065 { | |
5066 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5067 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5068 |
2449 | 5069 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5070 pred_pskip_motion(h, &mx, &my); |
5071 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5072 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5073 } | |
5074 | |
5075 write_back_motion(h, mb_type); | |
3927 | 5076 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5077 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5078 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
|
5079 h->prev_mb_skipped= 1; |
2396 | 5080 } |
5081 | |
5082 /** | |
1168 | 5083 * decodes a macroblock |
5084 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5085 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5086 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5087 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
|
5088 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5089 int partition_count; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5090 unsigned int mb_type, cbp; |
2755 | 5091 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5092 |
2967 | 5093 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5094 |
1170 | 5095 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5096 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5097 down the code */ | |
1168 | 5098 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5099 if(s->mb_skip_run==-1) | |
5100 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5101 |
1168 | 5102 if (s->mb_skip_run--) { |
3316 | 5103 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5104 if(s->mb_skip_run==0) | |
5105 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5106 else | |
5107 predict_field_decoding_flag(h); | |
5108 } | |
2396 | 5109 decode_mb_skip(h); |
1168 | 5110 return 0; |
5111 } | |
5112 } | |
3316 | 5113 if(FRAME_MBAFF){ |
5114 if( (s->mb_y&1) == 0 ) | |
5115 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5116 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5117 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5118 |
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
|
5119 h->prev_mb_skipped= 0; |
2967 | 5120 |
1168 | 5121 mb_type= get_ue_golomb(&s->gb); |
5122 if(h->slice_type == B_TYPE){ | |
5123 if(mb_type < 23){ | |
5124 partition_count= b_mb_type_info[mb_type].partition_count; | |
5125 mb_type= b_mb_type_info[mb_type].type; | |
5126 }else{ | |
5127 mb_type -= 23; | |
5128 goto decode_intra_mb; | |
5129 } | |
5130 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5131 if(mb_type < 5){ | |
5132 partition_count= p_mb_type_info[mb_type].partition_count; | |
5133 mb_type= p_mb_type_info[mb_type].type; | |
5134 }else{ | |
5135 mb_type -= 5; | |
5136 goto decode_intra_mb; | |
5137 } | |
5138 }else{ | |
5139 assert(h->slice_type == I_TYPE); | |
5140 decode_intra_mb: | |
5141 if(mb_type > 25){ | |
3954 | 5142 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 | 5143 return -1; |
5144 } | |
5145 partition_count=0; | |
5146 cbp= i_mb_type_info[mb_type].cbp; | |
5147 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5148 mb_type= i_mb_type_info[mb_type].type; | |
5149 } | |
5150 | |
3316 | 5151 if(MB_FIELD) |
1168 | 5152 mb_type |= MB_TYPE_INTERLACED; |
5153 | |
5154 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5155 |
1168 | 5156 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5157 unsigned int x, y; |
2967 | 5158 |
1168 | 5159 // we assume these blocks are very rare so we dont optimize it |
5160 align_get_bits(&s->gb); | |
2967 | 5161 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5162 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5163 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5164 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5165 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5166 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
|
5167 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5168 } |
5169 } | |
5170 for(y=0; y<8; y++){ | |
5171 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5172 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5173 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
|
5174 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5175 } |
5176 } | |
5177 for(y=0; y<8; y++){ | |
5178 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5179 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5180 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
|
5181 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5182 } |
5183 } | |
2967 | 5184 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5185 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5186 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
|
5187 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
|
5188 // 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
|
5189 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5190 |
2755 | 5191 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5192 return 0; |
5193 } | |
2967 | 5194 |
3316 | 5195 if(MB_MBAFF){ |
5196 h->ref_count[0] <<= 1; | |
5197 h->ref_count[1] <<= 1; | |
5198 } | |
5199 | |
2449 | 5200 fill_caches(h, mb_type, 0); |
1168 | 5201 |
5202 //mb_pred | |
5203 if(IS_INTRA(mb_type)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5204 int pred_mode; |
1168 | 5205 // init_top_left_availability(h); |
5206 if(IS_INTRA4x4(mb_type)){ | |
5207 int i; | |
2755 | 5208 int di = 1; |
5209 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5210 mb_type |= MB_TYPE_8x8DCT; | |
5211 di = 4; | |
5212 } | |
1168 | 5213 |
5214 // fill_intra4x4_pred_table(h); | |
2755 | 5215 for(i=0; i<16; i+=di){ |
3409 | 5216 int mode= pred_intra_mode(h, i); |
5217 | |
5218 if(!get_bits1(&s->gb)){ | |
1168 | 5219 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5220 mode = rem_mode + (rem_mode >= mode); |
1168 | 5221 } |
2967 | 5222 |
2755 | 5223 if(di==4) |
5224 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5225 else | |
5226 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5227 } |
5228 write_back_intra_pred_mode(h); | |
5229 if( check_intra4x4_pred_mode(h) < 0) | |
5230 return -1; | |
5231 }else{ | |
5232 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5233 if(h->intra16x16_pred_mode < 0) | |
5234 return -1; | |
5235 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5236 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5237 pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb)); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5238 if(pred_mode < 0) |
1168 | 5239 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5240 h->chroma_pred_mode= pred_mode; |
1168 | 5241 }else if(partition_count==4){ |
5242 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5243 |
1168 | 5244 if(h->slice_type == B_TYPE){ |
5245 for(i=0; i<4; i++){ | |
5246 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5247 if(h->sub_mb_type[i] >=13){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5248 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5249 return -1; |
5250 } | |
5251 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5252 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5253 } | |
2396 | 5254 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5255 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5256 pred_direct_motion(h, &mb_type); |
3003 | 5257 h->ref_cache[0][scan8[4]] = |
5258 h->ref_cache[1][scan8[4]] = | |
5259 h->ref_cache[0][scan8[12]] = | |
5260 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5261 } | |
1168 | 5262 }else{ |
5263 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5264 for(i=0; i<4; i++){ | |
5265 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5266 if(h->sub_mb_type[i] >=4){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5267 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5268 return -1; |
5269 } | |
5270 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5271 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5272 } | |
5273 } | |
2967 | 5274 |
4533 | 5275 for(list=0; list<h->list_count; list++){ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5276 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5277 for(i=0; i<4; i++){ |
2396 | 5278 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5279 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5280 unsigned int tmp = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5281 if(tmp>=ref_count){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5282 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5283 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5284 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5285 ref[list][i]= tmp; |
1168 | 5286 }else{ |
5287 //FIXME | |
5288 ref[list][i] = -1; | |
5289 } | |
5290 } | |
5291 } | |
2967 | 5292 |
2755 | 5293 if(dct8x8_allowed) |
5294 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5295 |
4533 | 5296 for(list=0; list<h->list_count; list++){ |
1168 | 5297 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
5298 | |
5299 for(i=0; i<4; i++){ | |
3003 | 5300 if(IS_DIRECT(h->sub_mb_type[i])) { |
5301 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5302 continue; | |
5303 } | |
1168 | 5304 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5305 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5306 | |
2396 | 5307 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5308 const int sub_mb_type= h->sub_mb_type[i]; |
5309 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5310 for(j=0; j<sub_partition_count[i]; j++){ | |
5311 int mx, my; | |
5312 const int index= 4*i + block_width*j; | |
5313 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5314 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5315 mx += get_se_golomb(&s->gb); | |
5316 my += get_se_golomb(&s->gb); | |
1170 | 5317 tprintf("final mv:%d %d\n", mx, my); |
5318 | |
1168 | 5319 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 5320 mv_cache[ 1 ][0]= |
1168 | 5321 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 5322 mv_cache[ 1 ][1]= |
1168 | 5323 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5324 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4530 | 5325 mv_cache[ 1 ][0]= mx; |
5326 mv_cache[ 1 ][1]= my; | |
1168 | 5327 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 5328 mv_cache[ 8 ][0]= mx; |
5329 mv_cache[ 8 ][1]= my; | |
1168 | 5330 } |
4530 | 5331 mv_cache[ 0 ][0]= mx; |
5332 mv_cache[ 0 ][1]= my; | |
1168 | 5333 } |
5334 }else{ | |
5335 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5336 p[0] = p[1]= | |
5337 p[8] = p[9]= 0; | |
5338 } | |
5339 } | |
5340 } | |
2396 | 5341 }else if(IS_DIRECT(mb_type)){ |
5342 pred_direct_motion(h, &mb_type); | |
2755 | 5343 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5344 }else{ |
1168 | 5345 int list, mx, my, i; |
5346 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5347 if(IS_16X16(mb_type)){ | |
4534 | 5348 for(list=0; list<h->list_count; list++){ |
5349 unsigned int val; | |
1168 | 5350 if(IS_DIR(mb_type, 0, list)){ |
4534 | 5351 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5352 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5353 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5354 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5355 } |
2523 | 5356 }else |
4534 | 5357 val= LIST_NOT_USED&0xFF; |
5358 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
5359 } | |
5360 for(list=0; list<h->list_count; list++){ | |
5361 unsigned int val; | |
1168 | 5362 if(IS_DIR(mb_type, 0, list)){ |
5363 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5364 mx += get_se_golomb(&s->gb); | |
5365 my += get_se_golomb(&s->gb); | |
1170 | 5366 tprintf("final mv:%d %d\n", mx, my); |
5367 | |
4534 | 5368 val= pack16to32(mx,my); |
2523 | 5369 }else |
4534 | 5370 val=0; |
5371 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4); | |
1168 | 5372 } |
5373 } | |
5374 else if(IS_16X8(mb_type)){ | |
4534 | 5375 for(list=0; list<h->list_count; list++){ |
1168 | 5376 for(i=0; i<2; i++){ |
4534 | 5377 unsigned int val; |
1168 | 5378 if(IS_DIR(mb_type, i, list)){ |
4534 | 5379 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5380 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5381 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5382 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5383 } |
2523 | 5384 }else |
4534 | 5385 val= LIST_NOT_USED&0xFF; |
5386 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
1168 | 5387 } |
4534 | 5388 } |
5389 for(list=0; list<h->list_count; list++){ | |
1168 | 5390 for(i=0; i<2; i++){ |
4534 | 5391 unsigned int val; |
1168 | 5392 if(IS_DIR(mb_type, i, list)){ |
5393 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5394 mx += get_se_golomb(&s->gb); | |
5395 my += get_se_golomb(&s->gb); | |
1170 | 5396 tprintf("final mv:%d %d\n", mx, my); |
5397 | |
4534 | 5398 val= pack16to32(mx,my); |
2396 | 5399 }else |
4534 | 5400 val=0; |
5401 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4); | |
1168 | 5402 } |
5403 } | |
5404 }else{ | |
5405 assert(IS_8X16(mb_type)); | |
4534 | 5406 for(list=0; list<h->list_count; list++){ |
1168 | 5407 for(i=0; i<2; i++){ |
4534 | 5408 unsigned int val; |
1168 | 5409 if(IS_DIR(mb_type, i, list)){ //FIXME optimize |
4534 | 5410 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5411 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5412 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5413 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5414 } |
2523 | 5415 }else |
4534 | 5416 val= LIST_NOT_USED&0xFF; |
5417 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
1168 | 5418 } |
4534 | 5419 } |
5420 for(list=0; list<h->list_count; list++){ | |
1168 | 5421 for(i=0; i<2; i++){ |
4534 | 5422 unsigned int val; |
1168 | 5423 if(IS_DIR(mb_type, i, list)){ |
5424 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5425 mx += get_se_golomb(&s->gb); | |
5426 my += get_se_golomb(&s->gb); | |
1170 | 5427 tprintf("final mv:%d %d\n", mx, my); |
5428 | |
4534 | 5429 val= pack16to32(mx,my); |
2396 | 5430 }else |
4534 | 5431 val=0; |
5432 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4); | |
1168 | 5433 } |
5434 } | |
5435 } | |
5436 } | |
2967 | 5437 |
1168 | 5438 if(IS_INTER(mb_type)) |
5439 write_back_motion(h, mb_type); | |
2967 | 5440 |
1168 | 5441 if(!IS_INTRA16x16(mb_type)){ |
5442 cbp= get_ue_golomb(&s->gb); | |
5443 if(cbp > 47){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5444 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5445 return -1; |
5446 } | |
2967 | 5447 |
1168 | 5448 if(IS_INTRA4x4(mb_type)) |
5449 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5450 else | |
5451 cbp= golomb_to_inter_cbp[cbp]; | |
5452 } | |
3651 | 5453 h->cbp = cbp; |
1168 | 5454 |
2755 | 5455 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5456 if(get_bits1(&s->gb)) | |
5457 mb_type |= MB_TYPE_8x8DCT; | |
5458 } | |
5459 s->current_picture.mb_type[mb_xy]= mb_type; | |
5460 | |
1168 | 5461 if(cbp || IS_INTRA16x16(mb_type)){ |
5462 int i8x8, i4x4, chroma_idx; | |
5463 int chroma_qp, dquant; | |
5464 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5465 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5466 |
1168 | 5467 // fill_non_zero_count_cache(h); |
5468 | |
5469 if(IS_INTERLACED(mb_type)){ | |
3316 | 5470 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5471 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5472 dc_scan= luma_dc_field_scan; |
5473 }else{ | |
3316 | 5474 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5475 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5476 dc_scan= luma_dc_zigzag_scan; |
5477 } | |
5478 | |
5479 dquant= get_se_golomb(&s->gb); | |
5480 | |
5481 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5482 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 | 5483 return -1; |
5484 } | |
2967 | 5485 |
1168 | 5486 s->qscale += dquant; |
5487 if(((unsigned)s->qscale) > 51){ | |
5488 if(s->qscale<0) s->qscale+= 52; | |
5489 else s->qscale-= 52; | |
5490 } | |
2967 | 5491 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5492 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5493 if(IS_INTRA16x16(mb_type)){ |
2919 | 5494 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
|
5495 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5496 } |
5497 | |
5498 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5499 | |
5500 if(cbp&15){ | |
5501 for(i8x8=0; i8x8<4; i8x8++){ | |
5502 for(i4x4=0; i4x4<4; i4x4++){ | |
5503 const int index= i4x4 + 4*i8x8; | |
2919 | 5504 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5505 return -1; |
5506 } | |
5507 } | |
5508 } | |
5509 }else{ | |
1636 | 5510 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5511 } |
5512 }else{ | |
5513 for(i8x8=0; i8x8<4; i8x8++){ | |
5514 if(cbp & (1<<i8x8)){ | |
2755 | 5515 if(IS_8x8DCT(mb_type)){ |
5516 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5517 uint8_t *nnz; |
2755 | 5518 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5519 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5520 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5521 return -1; |
5522 } | |
2757 | 5523 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
|
5524 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5525 }else{ |
5526 for(i4x4=0; i4x4<4; i4x4++){ | |
5527 const int index= i4x4 + 4*i8x8; | |
2967 | 5528 |
2919 | 5529 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 | 5530 return -1; |
5531 } | |
1168 | 5532 } |
5533 } | |
5534 }else{ | |
5535 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5536 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5537 } | |
5538 } | |
5539 } | |
2967 | 5540 |
1168 | 5541 if(cbp&0x30){ |
5542 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5543 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5544 return -1; |
5545 } | |
5546 } | |
5547 | |
5548 if(cbp&0x20){ | |
5549 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5550 for(i4x4=0; i4x4<4; i4x4++){ | |
5551 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5552 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 | 5553 return -1; |
5554 } | |
5555 } | |
5556 } | |
5557 }else{ | |
5558 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5559 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5560 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5561 } | |
5562 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5563 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
|
5564 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
|
5565 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
|
5566 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5567 } |
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
|
5568 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5569 write_back_non_zero_count(h); |
5570 | |
3316 | 5571 if(MB_MBAFF){ |
5572 h->ref_count[0] >>= 1; | |
5573 h->ref_count[1] >>= 1; | |
5574 } | |
5575 | |
1168 | 5576 return 0; |
5577 } | |
5578 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5579 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
|
5580 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
|
5581 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
|
5582 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
|
5583 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
|
5584 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
|
5585 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5586 unsigned int ctx = 0; |
2967 | 5587 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5588 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
|
5589 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5590 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5591 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
|
5592 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5593 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5594 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5595 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
|
5596 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5597 |
2312 | 5598 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5599 uint8_t *state= &h->cabac_state[ctx_base]; | |
5600 int mb_type; | |
2967 | 5601 |
2312 | 5602 if(intra_slice){ |
5603 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
|
5604 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
|
5605 const int mbb_xy = h->top_mb_xy; |
2312 | 5606 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5607 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
|
5608 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5609 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
|
5610 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5611 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5612 return 0; /* I4x4 */ |
5613 state += 2; | |
5614 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5615 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
|
5616 return 0; /* I4x4 */ |
2312 | 5617 } |
5618 | |
5619 if( get_cabac_terminate( &h->cabac ) ) | |
5620 return 25; /* PCM */ | |
5621 | |
5622 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
|
5623 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
|
5624 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
|
5625 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
|
5626 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
|
5627 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5628 return mb_type; |
5629 } | |
5630 | |
5631 static int decode_cabac_mb_type( H264Context *h ) { | |
5632 MpegEncContext * const s = &h->s; | |
5633 | |
5634 if( h->slice_type == I_TYPE ) { | |
5635 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
|
5636 } 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
|
5637 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
|
5638 /* 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
|
5639 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5640 /* 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
|
5641 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
|
5642 } else { |
3138 | 5643 /* 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
|
5644 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
|
5645 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5646 } else { |
2312 | 5647 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
|
5648 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5649 } 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
|
5650 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
|
5651 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
|
5652 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
|
5653 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5654 |
3138 | 5655 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
|
5656 ctx++; |
3138 | 5657 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
|
5658 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5659 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5660 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
|
5661 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
|
5662 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5663 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
|
5664 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
|
5665 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5666 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5667 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
|
5668 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
|
5669 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
|
5670 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
|
5671 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
|
5672 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
|
5673 else if( bits == 13 ) { |
2312 | 5674 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
|
5675 } 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
|
5676 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
|
5677 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
|
5678 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
|
5679 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5680 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
|
5681 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
|
5682 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5683 /* 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
|
5684 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
|
5685 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5686 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5687 |
3316 | 5688 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
|
5689 MpegEncContext * const s = &h->s; |
3316 | 5690 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
|
5691 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
|
5692 |
3316 | 5693 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5694 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5695 mba_xy = mb_xy - 1; | |
5696 if( (mb_y&1) | |
5697 && h->slice_table[mba_xy] == h->slice_num | |
5698 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5699 mba_xy += s->mb_stride; | |
5700 if( MB_FIELD ){ | |
5701 mbb_xy = mb_xy - s->mb_stride; | |
5702 if( !(mb_y&1) | |
5703 && h->slice_table[mbb_xy] == h->slice_num | |
5704 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5705 mbb_xy -= s->mb_stride; | |
5706 }else | |
5707 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5708 }else{ | |
5709 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5710 mba_xy = mb_xy - 1; | |
5711 mbb_xy = mb_xy - s->mb_stride; | |
5712 } | |
5713 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5714 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
|
5715 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5716 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
|
5717 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5718 |
3138 | 5719 if( h->slice_type == B_TYPE ) |
5720 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
|
5721 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
|
5722 } |
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 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
|
5725 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
|
5726 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5727 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
|
5728 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
|
5729 |
2928 | 5730 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5731 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5732 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5733 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5734 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
|
5735 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
|
5736 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5737 return mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5738 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5739 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5740 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
|
5741 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
|
5742 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
|
5743 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5744 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
|
5745 |
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
|
5746 /* 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
|
5747 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
|
5748 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
|
5749 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5750 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
|
5751 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5752 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5753 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
|
5754 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
|
5755 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5756 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
|
5757 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
|
5758 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
|
5759 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
|
5760 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5761 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
|
5762 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5763 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5764 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
|
5765 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
|
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 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
|
5768 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
|
5769 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5770 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
|
5771 { 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
|
5772 { 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
|
5773 { 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
|
5774 { 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
|
5775 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5776 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5777 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
|
5778 int cbp = 0; |
3138 | 5779 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
|
5780 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
|
5781 |
3138 | 5782 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5783 cbp_b = h->top_cbp; | |
5784 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5785 } | |
5786 | |
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 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
|
5788 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
|
5789 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
|
5790 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
|
5791 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5792 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
|
5793 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
|
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 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
|
5796 cbp_a = cbp; |
3138 | 5797 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
|
5798 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
|
5799 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
|
5800 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5801 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5802 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
|
5803 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
|
5804 |
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
|
5805 /* 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
|
5806 /* 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
|
5807 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
|
5808 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
|
5809 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
|
5810 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5811 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5812 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5813 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
|
5814 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
|
5815 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
|
5816 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
|
5817 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5818 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5819 if( 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
|
5820 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
|
5821 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5822 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5823 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
|
5824 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5825 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
|
5826 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
|
5827 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
|
5828 |
2314 | 5829 cbp_a = (h->left_cbp>>4)&0x03; |
5830 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
|
5831 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5832 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
|
5833 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
|
5834 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
|
5835 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
|
5836 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
|
5837 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5838 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
|
5839 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
|
5840 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
|
5841 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
|
5842 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5843 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
|
5844 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
|
5845 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
|
5846 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
|
5847 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
|
5848 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5849 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
|
5850 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
|
5851 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5852 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
|
5853 |
3316 | 5854 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
|
5855 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5856 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5857 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
|
5858 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
|
5859 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
|
5860 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5861 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
|
5862 val++; |
3128 | 5863 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5864 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
|
5865 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5866 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5867 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
|
5868 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
|
5869 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5870 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
|
5871 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5872 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
|
5873 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
|
5874 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
|
5875 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
|
5876 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
|
5877 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
|
5878 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
|
5879 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
|
5880 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5881 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
|
5882 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5883 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
|
5884 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
|
5885 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
|
5886 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
|
5887 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5888 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
|
5889 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
|
5890 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
|
5891 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5892 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5893 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
|
5894 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
|
5895 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5896 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5897 |
2755 | 5898 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
|
5899 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5900 } |
5901 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5902 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
|
5903 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
|
5904 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
|
5905 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
|
5906 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
|
5907 |
2396 | 5908 if( h->slice_type == B_TYPE) { |
5909 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5910 ctx++; | |
5911 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5912 ctx += 2; | |
5913 } else { | |
5914 if( refa > 0 ) | |
5915 ctx++; | |
5916 if( refb > 0 ) | |
5917 ctx += 2; | |
5918 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5919 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5920 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
|
5921 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5922 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
|
5923 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5924 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5925 ctx = 5; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5926 if(ref >= 32 /*h->ref_list[list]*/){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5927 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_ref\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5928 return 0; //FIXME we should return -1 and check the return everywhere |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5929 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5930 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5931 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5932 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5933 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5934 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
|
5935 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
|
5936 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
|
5937 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5938 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
|
5939 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5940 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
|
5941 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5942 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
|
5943 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5944 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5945 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5946 |
2317 | 5947 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5948 return 0; | |
5949 | |
5950 mvd= 1; | |
5951 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
|
5952 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
|
5953 mvd++; |
2317 | 5954 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
|
5955 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5956 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5957 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5958 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
|
5959 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
|
5960 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
|
5961 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
|
5962 k++; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5963 if(k>24){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5964 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5965 return INT_MIN; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5966 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5967 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5968 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5969 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
|
5970 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
|
5971 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5972 } |
4042 | 5973 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
|
5974 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5975 |
2316 | 5976 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5977 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
|
5978 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
|
5979 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5980 if( cat == 0 ) { |
2314 | 5981 nza = h->left_cbp&0x100; |
5982 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
|
5983 } else if( cat == 1 || cat == 2 ) { |
2314 | 5984 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5985 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
|
5986 } else if( cat == 3 ) { |
2314 | 5987 nza = (h->left_cbp>>(6+idx))&0x01; |
5988 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5989 } else { | |
5990 assert(cat == 4); | |
5991 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5992 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5993 } | |
5994 | |
5995 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
|
5996 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5997 |
2314 | 5998 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
|
5999 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
|
6000 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6001 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
|
6002 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6003 |
4051 | 6004 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
6005 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
6006 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
6007 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
6008 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
6009 }; | |
6010 | |
3028 | 6011 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
|
6012 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 6013 static const int significant_coeff_flag_offset[2][6] = { |
6014 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
6015 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
6016 }; | |
6017 static const int last_coeff_flag_offset[2][6] = { | |
6018 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
6019 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
6020 }; | |
6021 static const int coeff_abs_level_m1_offset[6] = { | |
6022 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
6023 }; | |
4007 | 6024 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 6025 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 6026 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
6027 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 6028 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
6029 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
6030 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
6031 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
6032 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 6033 }; |
6034 | |
6035 int index[64]; | |
2313 | 6036 |
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
|
6037 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
|
6038 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
|
6039 |
2316 | 6040 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
|
6041 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
|
6042 |
2898 | 6043 uint8_t *significant_coeff_ctx_base; |
6044 uint8_t *last_coeff_ctx_base; | |
6045 uint8_t *abs_level_m1_ctx_base; | |
2755 | 6046 |
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
|
6047 #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
|
6048 #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
|
6049 #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
|
6050 #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
|
6051 #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
|
6052 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
|
6053 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
|
6054 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
|
6055 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
|
6056 #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
|
6057 #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
|
6058 #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
|
6059 |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
6060 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6061 /* 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
|
6062 * 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
|
6063 * 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
|
6064 * 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
|
6065 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 6066 * 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
|
6067 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6068 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6069 /* read coded block flag */ |
2898 | 6070 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
|
6071 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 6072 if( cat == 1 || cat == 2 ) |
6073 h->non_zero_count_cache[scan8[n]] = 0; | |
6074 else if( cat == 4 ) | |
6075 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
|
6076 #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
|
6077 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
|
6078 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
|
6079 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
|
6080 #endif |
2755 | 6081 return 0; |
6082 } | |
2898 | 6083 } |
6084 | |
6085 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6086 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6087 last_coeff_ctx_base = h->cabac_state |
3316 | 6088 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6089 abs_level_m1_ctx_base = h->cabac_state |
6090 + coeff_abs_level_m1_offset[cat]; | |
6091 | |
6092 if( cat == 5 ) { | |
6093 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6094 for(last= 0; last < coefs; last++) { \ | |
6095 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
|
6096 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6097 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6098 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
|
6099 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6100 last= max_coeff; \ |
6101 break; \ | |
6102 } \ | |
6103 } \ | |
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
|
6104 }\ |
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
|
6105 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
|
6106 index[coeff_count++] = last;\ |
2898 | 6107 } |
4009 | 6108 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
|
6109 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6110 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6111 } else { | |
6112 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6113 #else | |
3316 | 6114 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6115 } else { |
6116 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
|
6117 #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
|
6118 } |
2316 | 6119 assert(coeff_count > 0); |
6120 | |
6121 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
|
6122 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
|
6123 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
|
6124 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6125 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
|
6126 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6127 else if( cat == 4 ) |
6128 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6129 else { |
2755 | 6130 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6131 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6132 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6133 |
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
|
6134 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6135 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
|
6136 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
|
6137 |
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
|
6138 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6139 if( !qmul ) { |
4040 | 6140 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6141 }else{ |
4040 | 6142 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6143 } |
2967 | 6144 |
2313 | 6145 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
|
6146 } else { |
2313 | 6147 int coeff_abs = 2; |
2898 | 6148 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
|
6149 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6150 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
|
6151 } |
2313 | 6152 |
6153 if( coeff_abs >= 15 ) { | |
6154 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
|
6155 while( get_cabac_bypass( CC ) ) { |
2313 | 6156 j++; |
6157 } | |
2967 | 6158 |
4016 | 6159 coeff_abs=1; |
2313 | 6160 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
|
6161 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6162 } |
4016 | 6163 coeff_abs+= 14; |
2313 | 6164 } |
6165 | |
2898 | 6166 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
|
6167 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6168 else block[j] = coeff_abs; |
6169 }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
|
6170 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6171 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6172 } |
2967 | 6173 |
2313 | 6174 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
|
6175 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6176 } |
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
|
6177 #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
|
6178 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
|
6179 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
|
6180 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
|
6181 #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
|
6182 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
|
6183 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6184 |
3077 | 6185 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
|
6186 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6187 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
|
6188 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
|
6189 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
|
6190 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6191 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
|
6192 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
|
6193 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
|
6194 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
|
6195 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6196 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
|
6197 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
|
6198 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6199 ? !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
|
6200 : (!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
|
6201 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6202 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
|
6203 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6204 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
|
6205 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
|
6206 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6207 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6208 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6209 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6210 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6211 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6212 * 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
|
6213 * @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
|
6214 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6215 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
|
6216 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
|
6217 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
|
6218 int mb_type, partition_count, cbp = 0; |
2755 | 6219 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
|
6220 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6221 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
|
6222 |
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
|
6223 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
|
6224 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6225 int skip; |
6226 /* a skipped mb needs the aff flag from the following mb */ | |
6227 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6228 predict_field_decoding_flag(h); | |
6229 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6230 skip = h->next_mb_skipped; | |
6231 else | |
6232 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
|
6233 /* read skip flags */ |
3316 | 6234 if( skip ) { |
6235 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6236 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6237 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6238 if(h->next_mb_skipped) | |
6239 predict_field_decoding_flag(h); | |
6240 else | |
6241 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6242 } | |
6243 | |
2396 | 6244 decode_mb_skip(h); |
6245 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6246 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
|
6247 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
|
6248 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
|
6249 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6250 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
|
6251 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6252 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6253 } |
3316 | 6254 if(FRAME_MBAFF){ |
6255 if( (s->mb_y&1) == 0 ) | |
6256 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
|
6257 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
|
6258 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6259 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
|
6260 |
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
|
6261 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
|
6262 |
3077 | 6263 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
|
6264 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
|
6265 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
|
6266 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
|
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 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6269 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
|
6270 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
|
6271 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
|
6272 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
|
6273 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6274 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
|
6275 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
|
6276 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6277 } 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
|
6278 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
|
6279 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
|
6280 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
|
6281 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6282 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
|
6283 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
|
6284 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6285 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6286 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
|
6287 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
|
6288 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
|
6289 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
|
6290 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
|
6291 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
|
6292 } |
3316 | 6293 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
|
6294 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
|
6295 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6296 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
|
6297 |
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(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6299 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6300 unsigned int x, y; |
2967 | 6301 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6302 // 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
|
6303 // 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
|
6304 // 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
|
6305 ptr= h->cabac.bytestream; |
4344 | 6306 if(h->cabac.low&0x1) ptr--; |
6307 if(CABAC_BITS==16){ | |
6308 if(h->cabac.low&0x1FF) ptr--; | |
6309 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6310 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6311 // 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
|
6312 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6313 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
|
6314 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6315 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6316 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
|
6317 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6318 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6319 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6320 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
|
6321 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6322 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
|
6323 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
|
6324 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6325 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6326 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6327 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
|
6328 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6329 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
|
6330 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
|
6331 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6332 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6333 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6334 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
|
6335 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6336 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6337 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
|
6338 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
|
6339 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6340 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
|
6341 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
|
6342 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6343 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6344 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
|
6345 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
|
6346 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6347 |
3316 | 6348 if(MB_MBAFF){ |
6349 h->ref_count[0] <<= 1; | |
6350 h->ref_count[1] <<= 1; | |
6351 } | |
6352 | |
2449 | 6353 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
|
6354 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6355 if( IS_INTRA( mb_type ) ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6356 int i, pred_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6357 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6358 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6359 mb_type |= MB_TYPE_8x8DCT; | |
6360 for( i = 0; i < 16; i+=4 ) { | |
6361 int pred = pred_intra_mode( h, i ); | |
6362 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6363 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6364 } | |
6365 } else { | |
6366 for( i = 0; i < 16; i++ ) { | |
6367 int pred = pred_intra_mode( h, i ); | |
6368 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
|
6369 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6370 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6371 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6372 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6373 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
|
6374 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
|
6375 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6376 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
|
6377 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
|
6378 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6379 h->chroma_pred_mode_table[mb_xy] = |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6380 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6381 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6382 pred_mode= check_intra_pred_mode( h, pred_mode ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6383 if( pred_mode < 0 ) return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6384 h->chroma_pred_mode= pred_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6385 } 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
|
6386 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
|
6387 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6388 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
|
6389 for( i = 0; i < 4; i++ ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6390 h->sub_mb_type[i] = decode_cabac_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
|
6391 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
|
6392 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
|
6393 } |
3482 | 6394 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6395 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6396 pred_direct_motion(h, &mb_type); |
6397 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6398 for( i = 0; i < 4; i++ ) | |
6399 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6400 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6401 } | |
6402 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6403 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6404 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
|
6405 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
|
6406 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
|
6407 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
|
6408 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6409 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6410 |
4533 | 6411 for( list = 0; list < h->list_count; list++ ) { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6412 for( i = 0; i < 4; i++ ) { |
2396 | 6413 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6414 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
|
6415 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
|
6416 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
|
6417 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6418 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
|
6419 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6420 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
|
6421 } |
2110 | 6422 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
|
6423 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
|
6424 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6425 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6426 |
2755 | 6427 if(dct8x8_allowed) |
6428 dct8x8_allowed = get_dct8x8_allowed(h); | |
6429 | |
4533 | 6430 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6431 for(i=0; i<4; i++){ |
2396 | 6432 if(IS_DIRECT(h->sub_mb_type[i])){ |
6433 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6434 continue; | |
6435 } | |
2110 | 6436 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
|
6437 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6438 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
|
6439 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
|
6440 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
|
6441 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
|
6442 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
|
6443 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
|
6444 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
|
6445 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
|
6446 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
|
6447 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
|
6448 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6449 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
|
6450 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
|
6451 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
|
6452 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6453 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 6454 mv_cache[ 1 ][0]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6455 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 6456 mv_cache[ 1 ][1]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6457 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
|
6458 |
4530 | 6459 mvd_cache[ 1 ][0]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6460 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
4530 | 6461 mvd_cache[ 1 ][1]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6462 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
|
6463 }else if(IS_SUB_8X4(sub_mb_type)){ |
4530 | 6464 mv_cache[ 1 ][0]= mx; |
6465 mv_cache[ 1 ][1]= my; | |
6466 | |
6467 mvd_cache[ 1 ][0]= mx - mpx; | |
6468 mvd_cache[ 1 ][1]= my - mpy; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6469 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 6470 mv_cache[ 8 ][0]= mx; |
6471 mv_cache[ 8 ][1]= my; | |
6472 | |
6473 mvd_cache[ 8 ][0]= mx - mpx; | |
6474 mvd_cache[ 8 ][1]= my - mpy; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6475 } |
4530 | 6476 mv_cache[ 0 ][0]= mx; |
6477 mv_cache[ 0 ][1]= my; | |
6478 | |
6479 mvd_cache[ 0 ][0]= mx - mpx; | |
6480 mvd_cache[ 0 ][1]= my - mpy; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6481 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6482 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6483 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
|
6484 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
|
6485 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
|
6486 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
|
6487 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6488 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6489 } |
2396 | 6490 } else if( IS_DIRECT(mb_type) ) { |
6491 pred_direct_motion(h, &mb_type); | |
6492 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6493 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6494 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6495 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6496 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
|
6497 if(IS_16X16(mb_type)){ |
4534 | 6498 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6499 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
|
6500 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
|
6501 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); |
2523 | 6502 }else |
4534 | 6503 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too |
6504 } | |
6505 for(list=0; list<h->list_count; list++){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6506 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
|
6507 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
|
6508 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6509 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
|
6510 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
|
6511 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
|
6512 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6513 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
|
6514 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6515 }else |
6516 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
|
6517 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6518 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6519 else if(IS_16X8(mb_type)){ |
4533 | 6520 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6521 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6522 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6523 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
|
6524 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6525 }else |
6526 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
|
6527 } |
4533 | 6528 } |
6529 for(list=0; list<h->list_count; list++){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6530 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6531 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6532 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
|
6533 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
|
6534 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
|
6535 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
|
6536 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6537 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
|
6538 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6539 }else{ |
2396 | 6540 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6541 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
|
6542 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6543 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6544 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6545 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6546 assert(IS_8X16(mb_type)); |
4533 | 6547 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6548 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
|
6549 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
|
6550 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
|
6551 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6552 }else |
6553 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
|
6554 } |
4533 | 6555 } |
6556 for(list=0; list<h->list_count; list++){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6557 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
|
6558 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
|
6559 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
|
6560 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
|
6561 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
|
6562 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6563 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
|
6564 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
|
6565 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6566 }else{ |
2396 | 6567 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6568 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
|
6569 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6570 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6571 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6572 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6573 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6574 |
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
|
6575 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
|
6576 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
|
6577 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
|
6578 } |
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 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
|
6581 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
|
6582 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
|
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 |
3651 | 6585 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
|
6586 |
2755 | 6587 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6588 if( decode_cabac_mb_transform_size( h ) ) | |
6589 mb_type |= MB_TYPE_8x8DCT; | |
6590 } | |
6591 s->current_picture.mb_type[mb_xy]= mb_type; | |
6592 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6593 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6594 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
|
6595 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
|
6596 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6597 if(IS_INTERLACED(mb_type)){ |
3316 | 6598 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6599 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
|
6600 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
|
6601 }else{ |
3316 | 6602 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6603 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
|
6604 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6607 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
|
6608 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6609 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
|
6610 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6611 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6612 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
|
6613 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
|
6614 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
|
6615 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
|
6616 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6617 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
|
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 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
|
6620 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
|
6621 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6622 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
|
6623 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
|
6624 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
|
6625 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
|
6626 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6627 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
|
6628 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
|
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 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6631 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
|
6632 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6633 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6634 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
|
6635 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
|
6636 if( cbp & (1<<i8x8) ) { |
2755 | 6637 if( IS_8x8DCT(mb_type) ) { |
6638 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6639 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6640 return -1; |
6641 } 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
|
6642 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
|
6643 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
|
6644 //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
|
6645 //START_TIMER |
2919 | 6646 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
|
6647 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6648 //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
|
6649 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6650 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6651 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
|
6652 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
|
6653 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6654 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6655 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6656 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6657 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
|
6658 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
|
6659 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
|
6660 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6661 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
|
6662 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
|
6663 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6664 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6665 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6666 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
|
6667 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
|
6668 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
|
6669 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
|
6670 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
|
6671 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6672 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
|
6673 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
|
6674 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6675 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6676 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6677 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
|
6678 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
|
6679 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
|
6680 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6681 } else { |
2315 | 6682 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6683 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6684 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6685 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6686 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
|
6687 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6688 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6689 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
|
6690 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
|
6691 |
3316 | 6692 if(MB_MBAFF){ |
6693 h->ref_count[0] >>= 1; | |
6694 h->ref_count[1] >>= 1; | |
6695 } | |
6696 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6697 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
|
6698 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6699 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6700 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6701 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
|
6702 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
|
6703 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
|
6704 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
|
6705 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
|
6706 |
2633 | 6707 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
|
6708 int8_t tc[4]; |
2633 | 6709 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
|
6710 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6711 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6712 } else { | |
6713 /* 16px edge length, because bS=4 is triggered by being at | |
6714 * the edge of an intra MB, so all 4 bS are the same */ | |
6715 for( d = 0; d < 16; d++ ) { | |
1898 | 6716 const int p0 = pix[-1]; |
6717 const int p1 = pix[-2]; | |
6718 const int p2 = pix[-3]; | |
6719 | |
6720 const int q0 = pix[0]; | |
6721 const int q1 = pix[1]; | |
6722 const int q2 = pix[2]; | |
6723 | |
4001 | 6724 if( FFABS( p0 - q0 ) < alpha && |
6725 FFABS( p1 - p0 ) < beta && | |
6726 FFABS( q1 - q0 ) < beta ) { | |
6727 | |
6728 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6729 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6730 { |
6731 const int p3 = pix[-4]; | |
6732 /* p0', p1', p2' */ | |
6733 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6734 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6735 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6736 } else { | |
6737 /* p0' */ | |
6738 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6739 } | |
4001 | 6740 if( FFABS( q2 - q0 ) < beta) |
1898 | 6741 { |
6742 const int q3 = pix[3]; | |
6743 /* q0', q1', q2' */ | |
6744 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6745 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6746 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6747 } else { | |
6748 /* q0' */ | |
6749 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6750 } | |
6751 }else{ | |
6752 /* p0', q0' */ | |
6753 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6754 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6755 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6756 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
|
6757 } |
1898 | 6758 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
|
6759 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6760 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6761 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6762 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6763 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6764 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
|
6765 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
|
6766 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
|
6767 |
2633 | 6768 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
|
6769 int8_t tc[4]; |
2633 | 6770 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
|
6771 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6772 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6773 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6774 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
|
6775 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6776 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6777 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6778 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
|
6779 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6780 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
|
6781 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6782 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6783 int beta; |
2967 | 6784 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6785 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6786 int bS_index = (i >> 1); |
3316 | 6787 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6788 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6789 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6790 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6791 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6792 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6793 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6794 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6795 |
3316 | 6796 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
|
6797 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
|
6798 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
|
6799 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
|
6800 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6801 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
|
6802 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
|
6803 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6804 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6805 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6806 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6807 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6808 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6809 |
4001 | 6810 if( FFABS( p0 - q0 ) < alpha && |
6811 FFABS( p1 - p0 ) < beta && | |
6812 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6813 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6814 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6815 |
4001 | 6816 if( FFABS( p2 - p0 ) < beta ) { |
4594 | 6817 pix[-2] = p1 + av_clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6818 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6819 } |
4001 | 6820 if( FFABS( q2 - q0 ) < beta ) { |
4594 | 6821 pix[1] = q1 + av_clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6822 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6823 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6824 |
4594 | 6825 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
6826 pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ | |
6827 pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 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
|
6829 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6830 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6831 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6832 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6833 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6834 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6835 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6836 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6837 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6838 |
4001 | 6839 if( FFABS( p0 - q0 ) < alpha && |
6840 FFABS( p1 - p0 ) < beta && | |
6841 FFABS( q1 - q0 ) < beta ) { | |
6842 | |
6843 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6844 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6845 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6847 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6848 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
|
6849 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
|
6850 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
|
6851 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6852 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6853 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
|
6854 } |
4001 | 6855 if( FFABS( q2 - q0 ) < beta) |
2581
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 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6858 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6859 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
|
6860 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
|
6861 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
|
6862 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6863 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6864 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
|
6865 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6866 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6867 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6868 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
|
6869 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
|
6870 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6871 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
|
6872 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6873 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6874 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6875 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6876 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
|
6877 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6878 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
|
6879 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6880 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6881 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6882 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6883 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6884 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6885 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6886 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6887 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6888 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6889 |
3316 | 6890 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
|
6891 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
|
6892 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
|
6893 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6894 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6895 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
|
6896 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
|
6897 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6898 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6899 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6900 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6901 |
4001 | 6902 if( FFABS( p0 - q0 ) < alpha && |
6903 FFABS( p1 - p0 ) < beta && | |
6904 FFABS( q1 - q0 ) < beta ) { | |
4594 | 6905 const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
6906 | |
6907 pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ | |
6908 pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6909 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
|
6910 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6911 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6912 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6913 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6914 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6915 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6916 |
4001 | 6917 if( FFABS( p0 - q0 ) < alpha && |
6918 FFABS( p1 - p0 ) < beta && | |
6919 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6920 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6921 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
|
6922 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
|
6923 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
|
6924 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6925 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6926 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6927 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6928 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6929 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
|
6930 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
|
6931 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
|
6932 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
|
6933 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
|
6934 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
|
6935 |
2633 | 6936 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
|
6937 int8_t tc[4]; |
2633 | 6938 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
|
6939 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6940 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6941 } else { | |
6942 /* 16px edge length, see filter_mb_edgev */ | |
6943 for( d = 0; d < 16; d++ ) { | |
1898 | 6944 const int p0 = pix[-1*pix_next]; |
6945 const int p1 = pix[-2*pix_next]; | |
6946 const int p2 = pix[-3*pix_next]; | |
6947 const int q0 = pix[0]; | |
6948 const int q1 = pix[1*pix_next]; | |
6949 const int q2 = pix[2*pix_next]; | |
6950 | |
4001 | 6951 if( FFABS( p0 - q0 ) < alpha && |
6952 FFABS( p1 - p0 ) < beta && | |
6953 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6954 |
6955 const int p3 = pix[-4*pix_next]; | |
6956 const int q3 = pix[ 3*pix_next]; | |
6957 | |
4001 | 6958 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6959 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6960 /* p0', p1', p2' */ |
6961 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6962 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6963 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6964 } else { | |
6965 /* p0' */ | |
6966 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6967 } | |
4001 | 6968 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6969 /* q0', q1', q2' */ |
6970 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6971 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6972 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6973 } else { | |
6974 /* q0' */ | |
6975 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6976 } | |
6977 }else{ | |
6978 /* p0', q0' */ | |
6979 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6980 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6981 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6982 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
|
6983 } |
1898 | 6984 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
|
6985 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6986 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6987 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6988 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6989 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6990 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6991 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
|
6992 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
|
6993 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
|
6994 |
2633 | 6995 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
|
6996 int8_t tc[4]; |
2633 | 6997 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
|
6998 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6999 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
7000 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
7001 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
|
7002 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7003 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7004 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7005 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
|
7006 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7007 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7008 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7009 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7010 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
|
7011 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
|
7012 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7013 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7014 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7015 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7016 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7017 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7018 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7019 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7020 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7021 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7022 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7023 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7024 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7025 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7027 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 7028 qp_thresh = 15 - h->slice_alpha_c0_offset; |
7029 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
7030 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
7031 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7032 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7033 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7034 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7035 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7036 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7037 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7038 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7039 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7040 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7041 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7043 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7045 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7046 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7047 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7048 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7049 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7050 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7051 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7052 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7053 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7054 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7055 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7056 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7057 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7058 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7059 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7060 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7061 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7062 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7063 int edges; |
7064 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7065 edges = 4; | |
7066 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7067 } else { | |
7068 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7069 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7070 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7071 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7072 ? 3 : 0; | |
7073 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7074 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7075 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7076 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7077 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7078 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7079 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7080 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7081 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7082 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7083 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7084 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7085 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
|
7086 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7087 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
|
7088 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
|
7089 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7090 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7091 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7092 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7093 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7094 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7095 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7096 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7097 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7098 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7099 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7100 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7101 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7102 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7103 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7104 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7105 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7106 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7107 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7108 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7109 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7110 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7111 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7112 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7113 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
|
7114 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
|
7115 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7116 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7117 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
|
7118 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
|
7119 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7120 /* 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
|
7121 * 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
|
7122 * frame numbers, not indices. */ |
3316 | 7123 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7124 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
|
7125 |
3101 | 7126 //for sufficiently low qp, filtering wouldn't do anything |
7127 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7128 if(!FRAME_MBAFF){ |
3101 | 7129 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7130 int qp = s->current_picture.qscale_table[mb_xy]; | |
7131 if(qp <= qp_thresh | |
7132 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7133 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7134 return; | |
7135 } | |
7136 } | |
7137 | |
3316 | 7138 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7139 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7140 && 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
|
7141 // and current and left pair do not have the same interlaced type |
3316 | 7142 && (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
|
7143 // 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
|
7144 && (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
|
7145 /* 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
|
7146 * 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
|
7147 */ |
3316 | 7148 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7149 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
|
7150 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7151 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7152 int chroma_qp[2]; |
3316 | 7153 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
|
7154 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7155 first_vertical_edge_done = 1; |
3316 | 7156 |
7157 if( IS_INTRA(mb_type) ) | |
7158 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7159 else { | |
7160 for( i = 0; i < 8; i++ ) { | |
7161 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7162 | |
7163 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7164 bS[i] = 4; | |
7165 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7166 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7167 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7168 bS[i] = 2; | |
7169 else | |
7170 bS[i] = 1; | |
7171 } | |
7172 } | |
7173 | |
7174 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7175 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7176 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7177 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7178 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7179 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7180 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7181 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7182 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7183 | |
7184 /* Filter edge */ | |
7185 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); | |
7186 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7187 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7188 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7189 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
|
7190 } |
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
|
7191 /* 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
|
7192 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
|
7193 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7194 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7195 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7196 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7197 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7198 | |
3101 | 7199 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7200 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7201 // how often to recheck mv-based bS when iterating between edges |
7202 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7203 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7204 // how often to recheck mv-based bS when iterating along each edge | |
7205 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7206 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7207 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7208 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7209 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7210 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7211 |
2454 | 7212 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
|
7213 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
|
7214 |
3316 | 7215 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7216 && !IS_INTERLACED(mb_type) | |
7217 && IS_INTERLACED(mbm_type) | |
7218 ) { | |
7219 // This is a special case in the norm where the filtering must | |
7220 // be done twice (one each of the field) even if we are in a | |
7221 // frame macroblock. | |
7222 // | |
7223 static const int nnz_idx[4] = {4,5,6,3}; | |
7224 unsigned int tmp_linesize = 2 * linesize; | |
7225 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7226 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7227 int qp, chroma_qp; | |
7228 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7229 int16_t bS[4]; |
3316 | 7230 |
7231 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7232 if( IS_INTRA(mb_type) || | |
7233 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7234 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7235 } else { | |
7236 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7237 for( i = 0; i < 4; i++ ) { | |
7238 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7239 mbn_nnz[nnz_idx[i]] != 0 ) | |
7240 bS[i] = 2; | |
7241 else | |
7242 bS[i] = 1; | |
7243 } | |
7244 } | |
7245 // Do not use s->qscale as luma quantizer because it has not the same | |
7246 // value in IPCM macroblocks. | |
7247 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7248 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); | |
7249 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7250 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7251 chroma_qp = ( h->chroma_qp + | |
7252 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7253 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7254 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7255 } | |
7256 | |
7257 start = 1; | |
7258 } | |
7259 | |
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
|
7260 /* Calculate bS */ |
2924 | 7261 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7262 /* mbn_xy: neighbor macroblock */ |
2924 | 7263 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7264 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7265 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
|
7266 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
|
7267 |
2924 | 7268 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7269 continue; |
7270 | |
2924 | 7271 if( IS_INTRA(mb_type) || |
7272 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7273 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7274 if (edge == 0) { |
2924 | 7275 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7276 || ((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
|
7277 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7278 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7279 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7280 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7281 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7282 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7283 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7284 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7285 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
|
7286 } else { |
2924 | 7287 int i, l; |
7288 int mv_done; | |
7289 | |
7290 if( edge & mask_edge ) { | |
7291 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7292 mv_done = 1; | |
7293 } | |
3316 | 7294 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7295 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7296 mv_done = 1; | |
7297 } | |
2924 | 7298 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7299 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7300 int bn_idx= b_idx - (dir ? 8:1); | |
7301 int v = 0; | |
7302 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7303 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7304 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7305 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7306 } |
7307 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7308 mv_done = 1; | |
7309 } | |
7310 else | |
7311 mv_done = 0; | |
7312 | |
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
|
7313 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
|
7314 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
|
7315 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
|
7316 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
|
7317 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
|
7318 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7319 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7320 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
|
7321 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
|
7322 } |
2924 | 7323 else if(!mv_done) |
2523 | 7324 { |
7325 bS[i] = 0; | |
7326 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
|
7327 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7328 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7329 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7330 bS[i] = 1; |
7331 break; | |
7332 } | |
7333 } | |
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
|
7334 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7335 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7336 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7337 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
|
7338 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
|
7339 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7340 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7341 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7342 // 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
|
7343 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7344 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
|
7345 //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
|
7346 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
|
7347 { 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
|
7348 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
|
7349 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7350 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
|
7351 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
|
7352 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
|
7353 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
|
7354 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
|
7355 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7356 } 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
|
7357 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7358 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
|
7359 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
|
7360 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
|
7361 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
|
7362 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
|
7363 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7364 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7365 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7366 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7367 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7368 |
1168 | 7369 static int decode_slice(H264Context *h){ |
7370 MpegEncContext * const s = &h->s; | |
7371 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7372 | |
7373 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
|
7374 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7375 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
|
7376 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
|
7377 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7378 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7379 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
|
7380 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7381 /* 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
|
7382 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
|
7383 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
|
7384 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7385 ( 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
|
7386 /* calculate pre-state */ |
2755 | 7387 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
|
7388 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
|
7389 if( h->slice_type == I_TYPE ) |
4594 | 7390 pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7391 else |
4594 | 7392 pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7393 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7394 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7395 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
|
7396 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7397 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7398 } |
7399 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7400 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7401 //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
|
7402 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
|
7403 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
|
7404 //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
|
7405 |
2163 | 7406 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7407 |
3316 | 7408 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
|
7409 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
|
7410 |
2163 | 7411 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
|
7412 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7413 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
|
7414 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
|
7415 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7416 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
|
7417 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7418 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
|
7419 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
|
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); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7421 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
|
7422 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7423 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7424 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
|
7425 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
|
7426 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7427 ++s->mb_y; |
3316 | 7428 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7429 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7430 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7431 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7432 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7433 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7434 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
|
7435 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
|
7436 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
|
7437 } |
1168 | 7438 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7439 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7440 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7441 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7442 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
|
7443 |
2163 | 7444 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
|
7445 |
3316 | 7446 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
|
7447 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
|
7448 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
|
7449 |
2163 | 7450 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
|
7451 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
|
7452 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7453 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7454 if(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
|
7455 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
|
7456 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
|
7457 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7458 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
|
7459 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7460 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7461 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
|
7462 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
|
7463 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
|
7464 ++s->mb_y; |
3316 | 7465 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7466 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7467 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7468 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
|
7469 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
|
7470 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7471 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
|
7472 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
|
7473 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7474 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
|
7475 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7476 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
|
7477 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7478 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
|
7479 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7480 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7481 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7482 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7483 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7484 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
|
7485 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7486 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); |
7487 | |
7488 return 0; | |
7489 }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
|
7490 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 | 7491 |
7492 return -1; | |
7493 } | |
7494 } | |
7495 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7496 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7497 |
1168 | 7498 #if 0 |
7499 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7500 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7501 int ret= decode_mb(h); | |
2967 | 7502 |
1168 | 7503 hl_decode_mb(h); |
7504 | |
7505 if(ret<0){ | |
3177 | 7506 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7507 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); |
7508 | |
7509 return -1; | |
7510 } | |
2967 | 7511 |
1168 | 7512 if(++s->mb_x >= s->mb_width){ |
7513 s->mb_x=0; | |
7514 if(++s->mb_y >= s->mb_height){ | |
7515 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7516 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); | |
7517 | |
7518 return 0; | |
7519 }else{ | |
7520 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); | |
7521 | |
7522 return -1; | |
7523 } | |
7524 } | |
7525 } | |
2967 | 7526 |
1168 | 7527 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7528 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7529 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); | |
7530 | |
7531 return 0; | |
7532 }else{ | |
7533 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); | |
7534 | |
7535 return -1; | |
7536 } | |
7537 } | |
7538 } | |
7539 s->mb_x=0; | |
7540 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7541 } | |
7542 #endif | |
7543 return -1; //not reached | |
7544 } | |
7545 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7546 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
|
7547 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7548 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7549 int e, build, i; |
2967 | 7550 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7551 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7552 return -1; |
2967 | 7553 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7554 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
|
7555 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
|
7556 } |
2967 | 7557 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7558 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7559 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
|
7560 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7561 h->x264_build= build; |
2967 | 7562 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7563 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
|
7564 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
|
7565 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7566 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7567 skip_bits(&s->gb, 8); |
2967 | 7568 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7569 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7570 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7571 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7572 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7573 MpegEncContext * const s = &h->s; |
2967 | 7574 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7575 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
|
7576 int size, type; |
2967 | 7577 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7578 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7579 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7580 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7581 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7582 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7583 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7584 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7585 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7586 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7587 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7588 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7589 case 5: |
3318 | 7590 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
|
7591 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7592 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7593 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7594 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7595 } |
2967 | 7596 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7597 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7598 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7599 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7600 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7601 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7602 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7603 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7604 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
|
7605 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7606 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7607 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
|
7608 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
|
7609 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
|
7610 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
|
7611 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
|
7612 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
|
7613 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
|
7614 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7615 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
|
7616 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
|
7617 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
|
7618 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
|
7619 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7620 |
1168 | 7621 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7622 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7623 int aspect_ratio_info_present_flag; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7624 unsigned int aspect_ratio_idc; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7625 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7626 |
7627 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7628 |
1168 | 7629 if( aspect_ratio_info_present_flag ) { |
7630 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7631 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7632 sps->sar.num= get_bits(&s->gb, 16); |
7633 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
|
7634 }else if(aspect_ratio_idc < 14){ |
1548 | 7635 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7636 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7637 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7638 return -1; |
7639 } | |
7640 }else{ | |
2967 | 7641 sps->sar.num= |
1548 | 7642 sps->sar.den= 0; |
1168 | 7643 } |
7644 // 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
|
7645 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7646 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
|
7647 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
|
7648 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7649 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7650 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
|
7651 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
|
7652 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
|
7653 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
|
7654 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
|
7655 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
|
7656 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
|
7657 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7658 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7659 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7660 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
|
7661 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
|
7662 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
|
7663 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7664 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7665 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
|
7666 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
|
7667 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
|
7668 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
|
7669 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
|
7670 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7671 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7672 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
|
7673 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
|
7674 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7675 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
|
7676 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
|
7677 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7678 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
|
7679 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
|
7680 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
|
7681 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7682 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
|
7683 if(sps->bitstream_restriction_flag){ |
4389 | 7684 unsigned int num_reorder_frames; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7685 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
|
7686 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
|
7687 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
|
7688 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
|
7689 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
4389 | 7690 num_reorder_frames= get_ue_golomb(&s->gb); |
7691 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/ | |
7692 | |
7693 if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){ | |
7694 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames); | |
7695 return -1; | |
7696 } | |
7697 | |
7698 sps->num_reorder_frames= num_reorder_frames; | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7699 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7700 |
1168 | 7701 return 0; |
7702 } | |
7703 | |
3004 | 7704 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7705 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7706 MpegEncContext * const s = &h->s; |
7707 int i, last = 8, next = 8; | |
7708 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7709 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7710 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7711 else |
7712 for(i=0;i<size;i++){ | |
7713 if(next) | |
7714 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7715 if(!i && !next){ /* matrix not written, we use the preset one */ |
7716 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7717 break; |
7718 } | |
7719 last = factors[scan[i]] = next ? next : last; | |
7720 } | |
7721 } | |
7722 | |
7723 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7724 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7725 MpegEncContext * const s = &h->s; | |
7726 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7727 const uint8_t *fallback[4] = { | |
7728 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7729 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7730 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7731 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7732 }; | |
7733 if(get_bits1(&s->gb)){ | |
7734 sps->scaling_matrix_present |= is_sps; | |
3004 | 7735 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7736 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7737 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7738 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7739 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7740 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7741 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7742 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7743 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7744 } |
7745 } else if(fallback_sps) { | |
7746 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7747 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7748 } | |
7749 } | |
7750 | |
1168 | 7751 static inline int decode_seq_parameter_set(H264Context *h){ |
7752 MpegEncContext * const s = &h->s; | |
1371 | 7753 int profile_idc, level_idc; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7754 unsigned int sps_id, tmp, mb_width, mb_height; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7755 int i; |
1168 | 7756 SPS *sps; |
2967 | 7757 |
1168 | 7758 profile_idc= get_bits(&s->gb, 8); |
1371 | 7759 get_bits1(&s->gb); //constraint_set0_flag |
7760 get_bits1(&s->gb); //constraint_set1_flag | |
7761 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7762 get_bits1(&s->gb); //constraint_set3_flag |
7763 get_bits(&s->gb, 4); // reserved | |
1168 | 7764 level_idc= get_bits(&s->gb, 8); |
7765 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7766 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7767 if (sps_id >= MAX_SPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7768 // ok it has gone out of hand, someone is sending us bad stuff. |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7769 av_log(h->s.avctx, AV_LOG_ERROR, "illegal sps_id (%d)\n", sps_id); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7770 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7771 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7772 |
1168 | 7773 sps= &h->sps_buffer[ sps_id ]; |
7774 sps->profile_idc= profile_idc; | |
7775 sps->level_idc= level_idc; | |
2312 | 7776 |
2755 | 7777 if(sps->profile_idc >= 100){ //high profile |
7778 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7779 get_bits1(&s->gb); //residual_color_transform_flag | |
7780 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7781 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7782 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7783 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7784 }else | |
7785 sps->scaling_matrix_present = 0; | |
2755 | 7786 |
1168 | 7787 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7788 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7789 |
1168 | 7790 if(sps->poc_type == 0){ //FIXME #define |
7791 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7792 } else if(sps->poc_type == 1){//FIXME #define | |
7793 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7794 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7795 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7796 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7797 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7798 if(tmp >= sizeof(sps->offset_for_ref_frame) / sizeof(sps->offset_for_ref_frame[0])){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7799 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7800 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7801 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7802 sps->poc_cycle_length= tmp; |
2967 | 7803 |
1168 | 7804 for(i=0; i<sps->poc_cycle_length; i++) |
7805 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7806 }else if(sps->poc_type != 2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7807 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7808 return -1; |
7809 } | |
7810 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7811 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7812 if(tmp > MAX_PICTURE_COUNT-2){ |
2254
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
7813 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
|
7814 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7815 sps->ref_frame_count= tmp; |
1371 | 7816 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7817 mb_width= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7818 mb_height= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7819 if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7820 avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7821 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n"); |
2422 | 7822 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7823 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7824 sps->mb_width = mb_width; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7825 sps->mb_height= mb_height; |
2422 | 7826 |
1168 | 7827 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7828 if(!sps->frame_mbs_only_flag) | |
7829 sps->mb_aff= get_bits1(&s->gb); | |
7830 else | |
7831 sps->mb_aff= 0; | |
7832 | |
7833 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7834 | |
3316 | 7835 #ifndef ALLOW_INTERLACE |
7836 if(sps->mb_aff) | |
3954 | 7837 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7838 #endif |
7839 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7840 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7841 | |
1371 | 7842 sps->crop= get_bits1(&s->gb); |
7843 if(sps->crop){ | |
7844 sps->crop_left = get_ue_golomb(&s->gb); | |
7845 sps->crop_right = get_ue_golomb(&s->gb); | |
7846 sps->crop_top = get_ue_golomb(&s->gb); | |
7847 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7848 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
|
7849 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7850 } |
7851 }else{ | |
2967 | 7852 sps->crop_left = |
7853 sps->crop_right = | |
7854 sps->crop_top = | |
1371 | 7855 sps->crop_bottom= 0; |
7856 } | |
7857 | |
1168 | 7858 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7859 if( sps->vui_parameters_present_flag ) | |
7860 decode_vui_parameters(h, sps); | |
2967 | 7861 |
1168 | 7862 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7863 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n", |
1168 | 7864 sps_id, sps->profile_idc, sps->level_idc, |
7865 sps->poc_type, | |
7866 sps->ref_frame_count, | |
7867 sps->mb_width, sps->mb_height, | |
7868 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7869 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7870 sps->crop_left, sps->crop_right, |
7871 sps->crop_top, sps->crop_bottom, | |
1168 | 7872 sps->vui_parameters_present_flag ? "VUI" : "" |
7873 ); | |
7874 } | |
7875 return 0; | |
7876 } | |
7877 | |
2755 | 7878 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7879 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7880 unsigned int tmp, pps_id= get_ue_golomb(&s->gb); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7881 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7882 |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7883 if(pps_id>=MAX_PPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7884 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7885 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7886 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7887 pps = &h->pps_buffer[pps_id]; |
2967 | 7888 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7889 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7890 if(tmp>=MAX_SPS_COUNT){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7891 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7892 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7893 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7894 pps->sps_id= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7895 |
1168 | 7896 pps->cabac= get_bits1(&s->gb); |
7897 pps->pic_order_present= get_bits1(&s->gb); | |
7898 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7899 if(pps->slice_group_count > 1 ){ | |
7900 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
|
7901 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7902 switch(pps->mb_slice_group_map_type){ |
7903 case 0: | |
7904 #if 0 | |
7905 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7906 | run_length[ i ] |1 |ue(v) | | |
7907 #endif | |
7908 break; | |
7909 case 2: | |
7910 #if 0 | |
7911 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7912 |{ | | | | |
7913 | top_left_mb[ i ] |1 |ue(v) | | |
7914 | bottom_right_mb[ i ] |1 |ue(v) | | |
7915 | } | | | | |
7916 #endif | |
7917 break; | |
7918 case 3: | |
7919 case 4: | |
7920 case 5: | |
7921 #if 0 | |
7922 | slice_group_change_direction_flag |1 |u(1) | | |
7923 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7924 #endif | |
7925 break; | |
7926 case 6: | |
7927 #if 0 | |
7928 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7929 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7930 |) | | | | |
7931 | slice_group_id[ i ] |1 |u(v) | | |
7932 #endif | |
1214 | 7933 break; |
1168 | 7934 } |
7935 } | |
7936 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7937 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4531 | 7938 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7939 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7940 pps->ref_count[0]= pps->ref_count[1]= 1; |
1168 | 7941 return -1; |
7942 } | |
2967 | 7943 |
1168 | 7944 pps->weighted_pred= get_bits1(&s->gb); |
7945 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7946 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7947 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7948 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7949 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7950 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7951 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7952 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7953 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
|
7954 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7955 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7956 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7957 |
7958 if(get_bits_count(&s->gb) < bit_length){ | |
7959 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7960 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7961 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7962 } | |
2967 | 7963 |
1168 | 7964 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7965 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n", |
1168 | 7966 pps_id, pps->sps_id, |
7967 pps->cabac ? "CABAC" : "CAVLC", | |
7968 pps->slice_group_count, | |
7969 pps->ref_count[0], pps->ref_count[1], | |
7970 pps->weighted_pred ? "weighted" : "", | |
7971 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7972 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7973 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7974 pps->redundant_pic_cnt_present ? "REDU" : "", |
7975 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7976 ); |
7977 } | |
2967 | 7978 |
1168 | 7979 return 0; |
7980 } | |
7981 | |
7982 /** | |
7983 * finds the end of the current frame in the bitstream. | |
7984 * @return the position of the first byte of the next frame, or -1 | |
7985 */ | |
2392 | 7986 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7987 int i; |
1168 | 7988 uint32_t state; |
2392 | 7989 ParseContext *pc = &(h->s.parse_context); |
1168 | 7990 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7991 // mb_addr= pc->mb_addr - 1; | |
7992 state= pc->state; | |
4592 | 7993 if(state>13) |
7994 state= 7; | |
7995 | |
7996 for(i=0; i<buf_size; i++){ | |
7997 if(state==7){ | |
7998 for(; i<buf_size; i++){ | |
7999 if(!buf[i]){ | |
8000 state=2; | |
8001 break; | |
8002 } | |
8003 } | |
8004 }else if(state<=2){ | |
8005 if(buf[i]==1) state^= 5; //2->7, 1->4, 0->5 | |
8006 else if(buf[i]) state = 7; | |
8007 else state>>=1; //2->1, 1->0, 0->0 | |
8008 }else if(state<=5){ | |
8009 int v= buf[i] & 0x1F; | |
8010 if(v==7 || v==8 || v==9){ | |
8011 if(pc->frame_start_found){ | |
8012 i++; | |
8013 found: | |
8014 pc->state=7; | |
2392 | 8015 pc->frame_start_found= 0; |
4592 | 8016 return i-(state&5); |
2392 | 8017 } |
4592 | 8018 }else if(v==1 || v==2 || v==5){ |
8019 if(pc->frame_start_found){ | |
8020 state+=8; | |
8021 continue; | |
8022 }else | |
8023 pc->frame_start_found = 1; | |
8024 } | |
8025 state= 7; | |
8026 }else{ | |
8027 if(buf[i] & 0x80) | |
8028 goto found; | |
8029 state= 7; | |
8030 } | |
8031 } | |
1168 | 8032 pc->state= state; |
1219 | 8033 return END_NOT_FOUND; |
1168 | 8034 } |
8035 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8036 #ifdef CONFIG_H264_PARSER |
1988 | 8037 static int h264_parse(AVCodecParserContext *s, |
8038 AVCodecContext *avctx, | |
2967 | 8039 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 8040 const uint8_t *buf, int buf_size) |
8041 { | |
2392 | 8042 H264Context *h = s->priv_data; |
8043 ParseContext *pc = &h->s.parse_context; | |
1988 | 8044 int next; |
2967 | 8045 |
2392 | 8046 next= find_frame_end(h, buf, buf_size); |
1988 | 8047 |
8048 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
8049 *poutbuf = NULL; | |
8050 *poutbuf_size = 0; | |
8051 return buf_size; | |
8052 } | |
8053 | |
4592 | 8054 if(next<0){ |
8055 find_frame_end(h, &pc->buffer[pc->last_index + next], -next); //update state | |
8056 } | |
8057 | |
1988 | 8058 *poutbuf = (uint8_t *)buf; |
8059 *poutbuf_size = buf_size; | |
8060 return next; | |
8061 } | |
8062 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8063 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8064 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8065 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8066 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8067 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8068 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8069 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8070 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8071 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8072 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8073 /* 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
|
8074 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8075 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
|
8076 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8077 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
|
8078 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8079 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8080 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8081 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8082 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8083 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8084 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8085 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8086 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8087 |
1168 | 8088 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
8089 MpegEncContext * const s = &h->s; | |
8090 AVCodecContext * const avctx= s->avctx; | |
8091 int buf_index=0; | |
1322 | 8092 #if 0 |
1168 | 8093 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8094 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8095 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 8096 } |
8097 #endif | |
2392 | 8098 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8099 s->current_picture_ptr= NULL; |
1168 | 8100 for(;;){ |
8101 int consumed; | |
8102 int dst_length; | |
8103 int bit_length; | |
8104 uint8_t *ptr; | |
2227 | 8105 int i, nalsize = 0; |
2967 | 8106 |
2227 | 8107 if(h->is_avc) { |
8108 if(buf_index >= buf_size) break; | |
8109 nalsize = 0; | |
8110 for(i = 0; i < h->nal_length_size; i++) | |
8111 nalsize = (nalsize << 8) | buf[buf_index++]; | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8112 if(nalsize <= 1 || nalsize > buf_size){ |
3126 | 8113 if(nalsize == 1){ |
8114 buf_index++; | |
8115 continue; | |
8116 }else{ | |
8117 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8118 break; | |
8119 } | |
8120 } | |
2227 | 8121 } else { |
1168 | 8122 // start code prefix search |
8123 for(; buf_index + 3 < buf_size; buf_index++){ | |
8124 // this should allways succeed in the first iteration | |
8125 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8126 break; | |
8127 } | |
2967 | 8128 |
1168 | 8129 if(buf_index+3 >= buf_size) break; |
2967 | 8130 |
1168 | 8131 buf_index+=3; |
2967 | 8132 } |
8133 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8134 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8135 if (ptr==NULL || dst_length <= 0){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8136 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8137 } |
3341 | 8138 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8139 dst_length--; | |
1168 | 8140 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8141 | |
8142 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8143 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 | 8144 } |
2967 | 8145 |
2227 | 8146 if (h->is_avc && (nalsize != consumed)) |
8147 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8148 | |
1168 | 8149 buf_index += consumed; |
8150 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8151 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8152 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8153 continue; |
2967 | 8154 |
1168 | 8155 switch(h->nal_unit_type){ |
8156 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8157 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8158 case NAL_SLICE: |
8159 init_get_bits(&s->gb, ptr, bit_length); | |
8160 h->intra_gb_ptr= | |
8161 h->inter_gb_ptr= &s->gb; | |
8162 s->data_partitioning = 0; | |
2967 | 8163 |
2771 | 8164 if(decode_slice_header(h) < 0){ |
8165 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8166 break; | |
8167 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8168 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8169 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8170 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8171 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8172 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8173 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8174 decode_slice(h); |
8175 break; | |
8176 case NAL_DPA: | |
8177 init_get_bits(&s->gb, ptr, bit_length); | |
8178 h->intra_gb_ptr= | |
8179 h->inter_gb_ptr= NULL; | |
8180 s->data_partitioning = 1; | |
2967 | 8181 |
2771 | 8182 if(decode_slice_header(h) < 0){ |
8183 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8184 } | |
1168 | 8185 break; |
8186 case NAL_DPB: | |
8187 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8188 h->intra_gb_ptr= &h->intra_gb; | |
8189 break; | |
8190 case NAL_DPC: | |
8191 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8192 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8193 |
2967 | 8194 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
|
8195 && s->context_initialized |
2793 | 8196 && s->hurry_up < 5 |
8197 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8198 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8199 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8200 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8201 decode_slice(h); |
8202 break; | |
8203 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8204 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
|
8205 decode_sei(h); |
1168 | 8206 break; |
8207 case NAL_SPS: | |
8208 init_get_bits(&s->gb, ptr, bit_length); | |
8209 decode_seq_parameter_set(h); | |
2967 | 8210 |
1168 | 8211 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8212 s->low_delay=1; | |
2967 | 8213 |
2538 | 8214 if(avctx->has_b_frames < 2) |
8215 avctx->has_b_frames= !s->low_delay; | |
1168 | 8216 break; |
8217 case NAL_PPS: | |
8218 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8219 |
2755 | 8220 decode_picture_parameter_set(h, bit_length); |
1168 | 8221 |
8222 break; | |
2960 | 8223 case NAL_AUD: |
8224 case NAL_END_SEQUENCE: | |
8225 case NAL_END_STREAM: | |
8226 case NAL_FILLER_DATA: | |
8227 case NAL_SPS_EXT: | |
8228 case NAL_AUXILIARY_SLICE: | |
1168 | 8229 break; |
2979 | 8230 default: |
8231 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8232 } |
8233 } | |
8234 | |
1174 | 8235 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
|
8236 |
2971 | 8237 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
|
8238 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8239 |
1168 | 8240 h->prev_frame_num_offset= h->frame_num_offset; |
8241 h->prev_frame_num= h->frame_num; | |
8242 if(s->current_picture_ptr->reference){ | |
8243 h->prev_poc_msb= h->poc_msb; | |
8244 h->prev_poc_lsb= h->poc_lsb; | |
8245 } | |
8246 if(s->current_picture_ptr->reference) | |
8247 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8248 | |
8249 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
|
8250 |
1168 | 8251 MPV_frame_end(s); |
8252 | |
8253 return buf_index; | |
8254 } | |
8255 | |
8256 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8257 * returns the number of bytes consumed for building the current frame |
1168 | 8258 */ |
8259 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8260 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8261 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8262 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8263 |
1168 | 8264 return pos; |
8265 }else{ | |
8266 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8267 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8268 | |
8269 return pos; | |
8270 } | |
8271 } | |
8272 | |
2967 | 8273 static int decode_frame(AVCodecContext *avctx, |
1168 | 8274 void *data, int *data_size, |
8275 uint8_t *buf, int buf_size) | |
8276 { | |
8277 H264Context *h = avctx->priv_data; | |
8278 MpegEncContext *s = &h->s; | |
2967 | 8279 AVFrame *pict = data; |
1168 | 8280 int buf_index; |
2967 | 8281 |
1168 | 8282 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8283 s->flags2= avctx->flags2; |
1168 | 8284 |
8285 /* no supplementary picture */ | |
8286 if (buf_size == 0) { | |
4556 | 8287 Picture *out; |
8288 int i, out_idx; | |
8289 | |
8290 //FIXME factorize this with the output code below | |
8291 out = h->delayed_pic[0]; | |
8292 out_idx = 0; | |
8293 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++) | |
8294 if(h->delayed_pic[i]->poc < out->poc){ | |
8295 out = h->delayed_pic[i]; | |
8296 out_idx = i; | |
8297 } | |
8298 | |
8299 for(i=out_idx; h->delayed_pic[i]; i++) | |
8300 h->delayed_pic[i] = h->delayed_pic[i+1]; | |
8301 | |
8302 if(out){ | |
8303 *data_size = sizeof(AVFrame); | |
8304 *pict= *(AVFrame*)out; | |
8305 } | |
8306 | |
1168 | 8307 return 0; |
8308 } | |
2967 | 8309 |
1168 | 8310 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8311 int next= find_frame_end(h, buf, buf_size); |
2967 | 8312 |
1988 | 8313 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8314 return buf_size; |
8315 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8316 } | |
8317 | |
2227 | 8318 if(h->is_avc && !h->got_avcC) { |
8319 int i, cnt, nalsize; | |
8320 unsigned char *p = avctx->extradata; | |
8321 if(avctx->extradata_size < 7) { | |
8322 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8323 return -1; | |
8324 } | |
8325 if(*p != 1) { | |
8326 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8327 return -1; | |
8328 } | |
8329 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8330 so put a fake nal_length_size = 2 while parsing them */ | |
8331 h->nal_length_size = 2; | |
8332 // Decode sps from avcC | |
8333 cnt = *(p+5) & 0x1f; // Number of sps | |
8334 p += 6; | |
8335 for (i = 0; i < cnt; i++) { | |
4364 | 8336 nalsize = AV_RB16(p) + 2; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8337 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8338 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8339 return -1; | |
8340 } | |
8341 p += nalsize; | |
2967 | 8342 } |
2227 | 8343 // Decode pps from avcC |
8344 cnt = *(p++); // Number of pps | |
8345 for (i = 0; i < cnt; i++) { | |
4364 | 8346 nalsize = AV_RB16(p) + 2; |
2227 | 8347 if(decode_nal_units(h, p, nalsize) != nalsize) { |
8348 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8349 return -1; | |
8350 } | |
8351 p += nalsize; | |
2967 | 8352 } |
2227 | 8353 // Now store right nal length size, that will be use to parse all other nals |
8354 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8355 // Do not reparse avcC | |
8356 h->got_avcC = 1; | |
8357 } | |
8358 | |
4507
b80c704183e9
always decode extradata when of non-avc stream (like RTSP)
gpoirier
parents:
4391
diff
changeset
|
8359 if(avctx->frame_number==0 && !h->is_avc && s->avctx->extradata_size){ |
2967 | 8360 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8361 return -1; |
8362 } | |
8363 | |
8364 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8365 if(buf_index < 0) |
1168 | 8366 return -1; |
8367 | |
2967 | 8368 //FIXME do something with unavailable reference frames |
8369 | |
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
|
8370 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8371 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8372 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8373 return -1; |
8374 } | |
8375 | |
2409 | 8376 { |
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
|
8377 Picture *out = s->current_picture_ptr; |
2561 | 8378 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8379 *data_size = sizeof(AVFrame); |
2561 | 8380 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8381 /* Sort B-frames into display order */ |
2409 | 8382 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
|
8383 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8384 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
|
8385 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8386 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
|
8387 && 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
|
8388 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
|
8389 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8390 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8391 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8392 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8393 while(h->delayed_pic[pics]) pics++; |
4388 | 8394 |
8395 assert(pics+1 < sizeof(h->delayed_pic) / sizeof(h->delayed_pic[0])); | |
8396 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8397 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
|
8398 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8399 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8400 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8401 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8402 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
|
8403 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
|
8404 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8405 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8406 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8407 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8408 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
|
8409 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
|
8410 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8411 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8412 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8413 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8414 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8415 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8416 { } | |
8417 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
|
8418 out = prev; |
2923 | 8419 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8420 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8421 ((!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
|
8422 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8423 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8424 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8425 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8426 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8427 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8428 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8429 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8430 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8431 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
|
8432 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
|
8433 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
|
8434 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8435 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8436 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8437 *data_size = 0; |
2561 | 8438 else |
8439 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8440 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
|
8441 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8442 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
|
8443 #endif |
2409 | 8444 |
2937 | 8445 if(out) |
8446 *pict= *(AVFrame*)out; | |
8447 else | |
8448 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8449 } | |
8450 | |
8451 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
|
8452 ff_print_debug_info(s, pict); |
1168 | 8453 //printf("out %d\n", (int)pict->data[0]); |
8454 #if 0 //? | |
8455 | |
8456 /* Return the Picture timestamp as the frame number */ | |
8457 /* we substract 1 because it is added on utils.c */ | |
8458 avctx->frame_number = s->picture_number - 1; | |
8459 #endif | |
8460 return get_consumed_bytes(s, buf_index, buf_size); | |
8461 } | |
8462 #if 0 | |
8463 static inline void fill_mb_avail(H264Context *h){ | |
8464 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
|
8465 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8466 |
8467 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
|
8468 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
|
8469 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
|
8470 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8471 }else{ |
8472 h->mb_avail[0]= | |
8473 h->mb_avail[1]= | |
8474 h->mb_avail[2]= 0; | |
8475 } | |
8476 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8477 h->mb_avail[4]= 1; //FIXME move out | |
8478 h->mb_avail[5]= 0; //FIXME move out | |
8479 } | |
8480 #endif | |
8481 | |
8482 #if 0 //selftest | |
8483 #define COUNT 8000 | |
8484 #define SIZE (COUNT*40) | |
8485 int main(){ | |
8486 int i; | |
8487 uint8_t temp[SIZE]; | |
8488 PutBitContext pb; | |
8489 GetBitContext gb; | |
8490 // int int_temp[10000]; | |
8491 DSPContext dsp; | |
8492 AVCodecContext avctx; | |
2967 | 8493 |
1168 | 8494 dsputil_init(&dsp, &avctx); |
8495 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8496 init_put_bits(&pb, temp, SIZE); |
1168 | 8497 printf("testing unsigned exp golomb\n"); |
8498 for(i=0; i<COUNT; i++){ | |
8499 START_TIMER | |
8500 set_ue_golomb(&pb, i); | |
8501 STOP_TIMER("set_ue_golomb"); | |
8502 } | |
8503 flush_put_bits(&pb); | |
2967 | 8504 |
1168 | 8505 init_get_bits(&gb, temp, 8*SIZE); |
8506 for(i=0; i<COUNT; i++){ | |
8507 int j, s; | |
2967 | 8508 |
1168 | 8509 s= show_bits(&gb, 24); |
2967 | 8510 |
1168 | 8511 START_TIMER |
8512 j= get_ue_golomb(&gb); | |
8513 if(j != i){ | |
8514 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8515 // return -1; | |
8516 } | |
8517 STOP_TIMER("get_ue_golomb"); | |
8518 } | |
2967 | 8519 |
8520 | |
1524 | 8521 init_put_bits(&pb, temp, SIZE); |
1168 | 8522 printf("testing signed exp golomb\n"); |
8523 for(i=0; i<COUNT; i++){ | |
8524 START_TIMER | |
8525 set_se_golomb(&pb, i - COUNT/2); | |
8526 STOP_TIMER("set_se_golomb"); | |
8527 } | |
8528 flush_put_bits(&pb); | |
2967 | 8529 |
1168 | 8530 init_get_bits(&gb, temp, 8*SIZE); |
8531 for(i=0; i<COUNT; i++){ | |
8532 int j, s; | |
2967 | 8533 |
1168 | 8534 s= show_bits(&gb, 24); |
2967 | 8535 |
1168 | 8536 START_TIMER |
8537 j= get_se_golomb(&gb); | |
8538 if(j != i - COUNT/2){ | |
8539 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8540 // return -1; | |
8541 } | |
8542 STOP_TIMER("get_se_golomb"); | |
8543 } | |
8544 | |
8545 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8546 |
1168 | 8547 DCTELEM block[16]; |
8548 uint8_t src[16], ref[16]; | |
8549 uint64_t error= 0, max_error=0; | |
8550 | |
8551 for(i=0; i<COUNT; i++){ | |
8552 int j; | |
8553 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8554 for(j=0; j<16; j++){ | |
8555 ref[j]= random()%255; | |
8556 src[j]= random()%255; | |
8557 } | |
8558 | |
8559 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8560 |
1168 | 8561 //normalize |
8562 for(j=0; j<16; j++){ | |
8563 // printf("%d ", block[j]); | |
8564 block[j]= block[j]*4; | |
8565 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8566 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8567 } | |
8568 // printf("\n"); | |
2967 | 8569 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8570 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8571 /* for(j=0; j<16; j++){ |
8572 printf("%d ", ref[j]); | |
8573 } | |
8574 printf("\n");*/ | |
2967 | 8575 |
1168 | 8576 for(j=0; j<16; j++){ |
4001 | 8577 int diff= FFABS(src[j] - ref[j]); |
2967 | 8578 |
1168 | 8579 error+= diff*diff; |
8580 max_error= FFMAX(max_error, diff); | |
8581 } | |
8582 } | |
8583 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8584 #if 0 | |
8585 printf("testing quantizer\n"); | |
8586 for(qp=0; qp<52; qp++){ | |
8587 for(i=0; i<16; i++) | |
8588 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8589 |
1168 | 8590 } |
8591 #endif | |
8592 printf("Testing NAL layer\n"); | |
2967 | 8593 |
1168 | 8594 uint8_t bitstream[COUNT]; |
8595 uint8_t nal[COUNT*2]; | |
8596 H264Context h; | |
8597 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8598 |
1168 | 8599 for(i=0; i<COUNT; i++){ |
8600 int zeros= i; | |
8601 int nal_length; | |
8602 int consumed; | |
8603 int out_length; | |
8604 uint8_t *out; | |
8605 int j; | |
2967 | 8606 |
1168 | 8607 for(j=0; j<COUNT; j++){ |
8608 bitstream[j]= (random() % 255) + 1; | |
8609 } | |
2967 | 8610 |
1168 | 8611 for(j=0; j<zeros; j++){ |
8612 int pos= random() % COUNT; | |
8613 while(bitstream[pos] == 0){ | |
8614 pos++; | |
8615 pos %= COUNT; | |
8616 } | |
8617 bitstream[pos]=0; | |
8618 } | |
2967 | 8619 |
1168 | 8620 START_TIMER |
2967 | 8621 |
1168 | 8622 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8623 if(nal_length<0){ | |
8624 printf("encoding failed\n"); | |
8625 return -1; | |
8626 } | |
2967 | 8627 |
1168 | 8628 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8629 | |
8630 STOP_TIMER("NAL") | |
2967 | 8631 |
1168 | 8632 if(out_length != COUNT){ |
8633 printf("incorrect length %d %d\n", out_length, COUNT); | |
8634 return -1; | |
8635 } | |
2967 | 8636 |
1168 | 8637 if(consumed != nal_length){ |
8638 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8639 return -1; | |
8640 } | |
2967 | 8641 |
1168 | 8642 if(memcmp(bitstream, out, COUNT)){ |
8643 printf("missmatch\n"); | |
8644 return -1; | |
8645 } | |
8646 } | |
2967 | 8647 |
1168 | 8648 printf("Testing RBSP\n"); |
2967 | 8649 |
8650 | |
1168 | 8651 return 0; |
8652 } | |
8653 #endif | |
8654 | |
8655 | |
8656 static int decode_end(AVCodecContext *avctx) | |
8657 { | |
8658 H264Context *h = avctx->priv_data; | |
8659 MpegEncContext *s = &h->s; | |
2967 | 8660 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8661 av_freep(&h->rbsp_buffer); |
1168 | 8662 free_tables(h); //FIXME cleanup init stuff perhaps |
8663 MPV_common_end(s); | |
8664 | |
8665 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8666 |
1168 | 8667 return 0; |
8668 } | |
8669 | |
8670 | |
8671 AVCodec h264_decoder = { | |
8672 "h264", | |
8673 CODEC_TYPE_VIDEO, | |
8674 CODEC_ID_H264, | |
8675 sizeof(H264Context), | |
8676 decode_init, | |
8677 NULL, | |
8678 decode_end, | |
8679 decode_frame, | |
2453 | 8680 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8681 .flush= flush_dpb, |
1168 | 8682 }; |
8683 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8684 #ifdef CONFIG_H264_PARSER |
1988 | 8685 AVCodecParser h264_parser = { |
8686 { CODEC_ID_H264 }, | |
2392 | 8687 sizeof(H264Context), |
1988 | 8688 NULL, |
8689 h264_parse, | |
8690 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8691 h264_split, |
1988 | 8692 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8693 #endif |
1988 | 8694 |
1234 | 8695 #include "svq3.c" |