Mercurial > libavcodec.hg
annotate h264.c @ 4362:0271b214458b libavcodec
harden h264 decoding to prevent some crashes when input data is corrupted.
Patch by Frank %eucloid A gmail P com%
date: Jan 18, 2007 6:48 PM
subject: Re: [Ffmpeg-devel] h264, protection against corrupted data (second try patch)
AND
date: Jan 17, 2007 8:22 PM
subject: [Ffmpeg-devel] h264, protection against corrupted data
this also fixes a possible security issue (the sps and pps ids where not checked,
then used as index into an array of sps/pps structs which was then filled with data from the bitstream)
author | gpoirier |
---|---|
date | Fri, 19 Jan 2007 09:37:04 +0000 |
parents | d18568fb0187 |
children | 9b7662fa4905 |
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; | |
125 int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 | |
126 int weighted_pred; ///< weighted_pred_flag | |
127 int weighted_bipred_idc; | |
128 int init_qp; ///< pic_init_qp_minus26 + 26 | |
129 int init_qs; ///< pic_init_qs_minus26 + 26 | |
130 int chroma_qp_index_offset; | |
131 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag | |
132 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
133 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
2755 | 134 int transform_8x8_mode; ///< transform_8x8_mode_flag |
2919 | 135 uint8_t scaling_matrix4[6][16]; |
136 uint8_t scaling_matrix8[2][64]; | |
1168 | 137 }PPS; |
138 | |
139 /** | |
140 * Memory management control operation opcode. | |
141 */ | |
142 typedef enum MMCOOpcode{ | |
143 MMCO_END=0, | |
144 MMCO_SHORT2UNUSED, | |
145 MMCO_LONG2UNUSED, | |
146 MMCO_SHORT2LONG, | |
147 MMCO_SET_MAX_LONG, | |
2967 | 148 MMCO_RESET, |
1168 | 149 MMCO_LONG, |
150 } MMCOOpcode; | |
151 | |
152 /** | |
153 * Memory management control operation. | |
154 */ | |
155 typedef struct MMCO{ | |
156 MMCOOpcode opcode; | |
157 int short_frame_num; | |
158 int long_index; | |
159 } MMCO; | |
160 | |
161 /** | |
162 * H264Context | |
163 */ | |
164 typedef struct H264Context{ | |
165 MpegEncContext s; | |
2967 | 166 int nal_ref_idc; |
1168 | 167 int nal_unit_type; |
168 uint8_t *rbsp_buffer; | |
3066
04b924f8f5a5
warning fixes by Luca Abeni, lucabe72 ##@## email ##.## it
diego
parents:
3063
diff
changeset
|
169 unsigned int rbsp_buffer_size; |
1168 | 170 |
2227 | 171 /** |
172 * Used to parse AVC variant of h264 | |
173 */ | |
174 int is_avc; ///< this flag is != 0 if codec is avc1 | |
175 int got_avcC; ///< flag used to parse avcC data only once | |
176 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
177 | |
1168 | 178 int chroma_qp; //QPc |
179 | |
3316 | 180 int prev_mb_skipped; |
181 int next_mb_skipped; | |
1168 | 182 |
183 //prediction stuff | |
184 int chroma_pred_mode; | |
185 int intra16x16_pred_mode; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
186 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
187 int top_mb_xy; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
188 int left_mb_xy[2]; |
2967 | 189 |
1168 | 190 int8_t intra4x4_pred_mode_cache[5*8]; |
191 int8_t (*intra4x4_pred_mode)[8]; | |
192 void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp? | |
2755 | 193 void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride); |
1168 | 194 void (*pred8x8 [4+3])(uint8_t *src, int stride); |
195 void (*pred16x16[4+3])(uint8_t *src, int stride); | |
196 unsigned int topleft_samples_available; | |
197 unsigned int top_samples_available; | |
198 unsigned int topright_samples_available; | |
199 unsigned int left_samples_available; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
200 uint8_t (*top_borders[2])[16+2*8]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
201 uint8_t left_border[2*(17+2*9)]; |
1168 | 202 |
203 /** | |
204 * non zero coeff count cache. | |
205 * is 64 if not available. | |
206 */ | |
3089 | 207 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
208 uint8_t (*non_zero_count)[16]; |
1168 | 209 |
210 /** | |
211 * Motion vector cache. | |
212 */ | |
3089 | 213 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); |
214 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); | |
1168 | 215 #define LIST_NOT_USED -1 //FIXME rename? |
216 #define PART_NOT_AVAILABLE -2 | |
2967 | 217 |
1168 | 218 /** |
219 * is 1 if the specific list MV&references are set to 0,0,-2. | |
220 */ | |
221 int mv_cache_clean[2]; | |
222 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
223 /** |
2755 | 224 * number of neighbors (top and/or left) that used 8x8 dct |
225 */ | |
226 int neighbor_transform_size; | |
227 | |
228 /** | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
229 * block_offset[ 0..23] for frame macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
230 * block_offset[24..47] for field macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
231 */ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
232 int block_offset[2*(16+8)]; |
2967 | 233 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
234 uint32_t *mb2b_xy; //FIXME are these 4 a good idea? |
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
235 uint32_t *mb2b8_xy; |
2395 | 236 int b_stride; //FIXME use s->b4_stride |
1168 | 237 int b8_stride; |
238 | |
3316 | 239 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff |
240 int mb_uvlinesize; | |
241 | |
242 int emu_edge_width; | |
243 int emu_edge_height; | |
244 | |
1234 | 245 int halfpel_flag; |
246 int thirdpel_flag; | |
247 | |
1319 | 248 int unknown_svq3_flag; |
249 int next_slice_index; | |
250 | |
1168 | 251 SPS sps_buffer[MAX_SPS_COUNT]; |
252 SPS sps; ///< current sps | |
2967 | 253 |
1168 | 254 PPS pps_buffer[MAX_PPS_COUNT]; |
255 /** | |
256 * current pps | |
257 */ | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
258 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? |
1168 | 259 |
2919 | 260 uint32_t dequant4_buffer[6][52][16]; |
261 uint32_t dequant8_buffer[2][52][64]; | |
262 uint32_t (*dequant4_coeff[6])[16]; | |
263 uint32_t (*dequant8_coeff[2])[64]; | |
264 int dequant_coeff_pps; ///< reinit tables when pps changes | |
2755 | 265 |
1168 | 266 int slice_num; |
267 uint8_t *slice_table_base; | |
3316 | 268 uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
1168 | 269 int slice_type; |
270 int slice_type_fixed; | |
2967 | 271 |
1168 | 272 //interlacing specific flags |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
273 int mb_aff_frame; |
1168 | 274 int mb_field_decoding_flag; |
3316 | 275 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag |
2967 | 276 |
1168 | 277 int sub_mb_type[4]; |
2967 | 278 |
1168 | 279 //POC stuff |
280 int poc_lsb; | |
281 int poc_msb; | |
282 int delta_poc_bottom; | |
283 int delta_poc[2]; | |
284 int frame_num; | |
285 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
286 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
287 int frame_num_offset; ///< for POC type 2 | |
288 int prev_frame_num_offset; ///< for POC type 2 | |
289 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
290 | |
291 /** | |
292 * frame_num for frames or 2*frame_num for field pics. | |
293 */ | |
294 int curr_pic_num; | |
2967 | 295 |
1168 | 296 /** |
297 * max_frame_num or 2*max_frame_num for field pics. | |
298 */ | |
299 int max_pic_num; | |
300 | |
301 //Weighted pred stuff | |
2415 | 302 int use_weight; |
303 int use_weight_chroma; | |
1168 | 304 int luma_log2_weight_denom; |
305 int chroma_log2_weight_denom; | |
3316 | 306 int luma_weight[2][48]; |
307 int luma_offset[2][48]; | |
308 int chroma_weight[2][48][2]; | |
309 int chroma_offset[2][48][2]; | |
310 int implicit_weight[48][48]; | |
2967 | 311 |
1168 | 312 //deblock |
2967 | 313 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
314 int slice_alpha_c0_offset; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
315 int slice_beta_offset; |
2967 | 316 |
1168 | 317 int redundant_pic_count; |
2967 | 318 |
1168 | 319 int direct_spatial_mv_pred; |
2396 | 320 int dist_scale_factor[16]; |
3316 | 321 int dist_scale_factor_field[32]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
322 int map_col_to_list0[2][16]; |
3316 | 323 int map_col_to_list0_field[2][32]; |
1168 | 324 |
325 /** | |
326 * num_ref_idx_l0/1_active_minus1 + 1 | |
327 */ | |
3316 | 328 int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
2582 | 329 Picture *short_ref[32]; |
330 Picture *long_ref[32]; | |
1168 | 331 Picture default_ref_list[2][32]; |
3316 | 332 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs |
2409 | 333 Picture *delayed_pic[16]; //FIXME size? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
334 Picture *delayed_output_pic; |
2967 | 335 |
1168 | 336 /** |
337 * memory management control operations buffer. | |
338 */ | |
339 MMCO mmco[MAX_MMCO_COUNT]; | |
340 int mmco_index; | |
2967 | 341 |
1168 | 342 int long_ref_count; ///< number of actual long term references |
343 int short_ref_count; ///< number of actual short term references | |
2967 | 344 |
1168 | 345 //data partitioning |
346 GetBitContext intra_gb; | |
347 GetBitContext inter_gb; | |
348 GetBitContext *intra_gb_ptr; | |
349 GetBitContext *inter_gb_ptr; | |
2967 | 350 |
3089 | 351 DECLARE_ALIGNED_8(DCTELEM, mb[16*24]); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
352 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
353 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
354 * Cabac |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
355 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
356 CABACContext cabac; |
2755 | 357 uint8_t cabac_state[460]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
358 int cabac_init_idc; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
359 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
360 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
361 uint16_t *cbp_table; |
3651 | 362 int cbp; |
2314 | 363 int top_cbp; |
364 int left_cbp; | |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
365 /* chroma_pred_mode for i4x4 or i16x16, else 0 */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
366 uint8_t *chroma_pred_mode_table; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
367 int last_qscale_diff; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
368 int16_t (*mvd_table[2])[2]; |
3089 | 369 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); |
2396 | 370 uint8_t *direct_table; |
371 uint8_t direct_cache[5*8]; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
372 |
2748
135aa7d0bd17
avoid one transpose (730->680 dezicycles on duron)
michael
parents:
2717
diff
changeset
|
373 uint8_t zigzag_scan[16]; |
3174 | 374 uint8_t zigzag_scan8x8[64]; |
375 uint8_t zigzag_scan8x8_cavlc[64]; | |
3316 | 376 uint8_t field_scan[16]; |
377 uint8_t field_scan8x8[64]; | |
378 uint8_t field_scan8x8_cavlc[64]; | |
2763 | 379 const uint8_t *zigzag_scan_q0; |
3174 | 380 const uint8_t *zigzag_scan8x8_q0; |
381 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
3316 | 382 const uint8_t *field_scan_q0; |
383 const uint8_t *field_scan8x8_q0; | |
384 const uint8_t *field_scan8x8_cavlc_q0; | |
2967 | 385 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
386 int x264_build; |
1168 | 387 }H264Context; |
388 | |
389 static VLC coeff_token_vlc[4]; | |
390 static VLC chroma_dc_coeff_token_vlc; | |
391 | |
392 static VLC total_zeros_vlc[15]; | |
393 static VLC chroma_dc_total_zeros_vlc[3]; | |
394 | |
395 static VLC run_vlc[6]; | |
396 static VLC run7_vlc; | |
397 | |
1234 | 398 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
399 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc); | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
400 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize); |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
401 static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize); |
1234 | 402 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
403 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 404 #ifdef WORDS_BIGENDIAN |
405 return (b&0xFFFF) + (a<<16); | |
406 #else | |
407 return (a&0xFFFF) + (b<<16); | |
408 #endif | |
409 } | |
410 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
411 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
412 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
413 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
414 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
415 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
416 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
417 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
418 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
419 |
1168 | 420 /** |
421 * fill a rectangle. | |
2392 | 422 * @param h height of the rectangle, should be a constant |
423 * @param w width of the rectangle, should be a constant | |
1168 | 424 * @param size the size of val (1 or 4), should be a constant |
425 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
426 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 427 uint8_t *p= (uint8_t*)vp; |
1168 | 428 assert(size==1 || size==4); |
3315 | 429 assert(w<=4); |
2967 | 430 |
1168 | 431 w *= size; |
432 stride *= size; | |
2967 | 433 |
2962 | 434 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 435 assert((stride&(w-1))==0); |
3315 | 436 if(w==2){ |
437 const uint16_t v= size==4 ? val : val*0x0101; | |
438 *(uint16_t*)(p + 0*stride)= v; | |
439 if(h==1) return; | |
440 *(uint16_t*)(p + 1*stride)= v; | |
441 if(h==2) return; | |
1168 | 442 *(uint16_t*)(p + 2*stride)= |
3315 | 443 *(uint16_t*)(p + 3*stride)= v; |
444 }else if(w==4){ | |
445 const uint32_t v= size==4 ? val : val*0x01010101; | |
446 *(uint32_t*)(p + 0*stride)= v; | |
447 if(h==1) return; | |
448 *(uint32_t*)(p + 1*stride)= v; | |
449 if(h==2) return; | |
1168 | 450 *(uint32_t*)(p + 2*stride)= |
3315 | 451 *(uint32_t*)(p + 3*stride)= v; |
452 }else if(w==8){ | |
453 //gcc can't optimize 64bit math on x86_32 | |
454 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
455 const uint64_t v= val*0x0100000001ULL; | |
456 *(uint64_t*)(p + 0*stride)= v; | |
457 if(h==1) return; | |
458 *(uint64_t*)(p + 1*stride)= v; | |
459 if(h==2) return; | |
1168 | 460 *(uint64_t*)(p + 2*stride)= |
3315 | 461 *(uint64_t*)(p + 3*stride)= v; |
462 }else if(w==16){ | |
463 const uint64_t v= val*0x0100000001ULL; | |
1168 | 464 *(uint64_t*)(p + 0+0*stride)= |
465 *(uint64_t*)(p + 8+0*stride)= | |
466 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 467 *(uint64_t*)(p + 8+1*stride)= v; |
468 if(h==2) return; | |
1168 | 469 *(uint64_t*)(p + 0+2*stride)= |
470 *(uint64_t*)(p + 8+2*stride)= | |
471 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 472 *(uint64_t*)(p + 8+3*stride)= v; |
473 #else | |
474 *(uint32_t*)(p + 0+0*stride)= | |
475 *(uint32_t*)(p + 4+0*stride)= val; | |
476 if(h==1) return; | |
477 *(uint32_t*)(p + 0+1*stride)= | |
478 *(uint32_t*)(p + 4+1*stride)= val; | |
479 if(h==2) return; | |
480 *(uint32_t*)(p + 0+2*stride)= | |
481 *(uint32_t*)(p + 4+2*stride)= | |
482 *(uint32_t*)(p + 0+3*stride)= | |
483 *(uint32_t*)(p + 4+3*stride)= val; | |
484 }else if(w==16){ | |
485 *(uint32_t*)(p + 0+0*stride)= | |
486 *(uint32_t*)(p + 4+0*stride)= | |
487 *(uint32_t*)(p + 8+0*stride)= | |
488 *(uint32_t*)(p +12+0*stride)= | |
489 *(uint32_t*)(p + 0+1*stride)= | |
490 *(uint32_t*)(p + 4+1*stride)= | |
491 *(uint32_t*)(p + 8+1*stride)= | |
492 *(uint32_t*)(p +12+1*stride)= val; | |
493 if(h==2) return; | |
494 *(uint32_t*)(p + 0+2*stride)= | |
495 *(uint32_t*)(p + 4+2*stride)= | |
496 *(uint32_t*)(p + 8+2*stride)= | |
497 *(uint32_t*)(p +12+2*stride)= | |
498 *(uint32_t*)(p + 0+3*stride)= | |
499 *(uint32_t*)(p + 4+3*stride)= | |
500 *(uint32_t*)(p + 8+3*stride)= | |
501 *(uint32_t*)(p +12+3*stride)= val; | |
502 #endif | |
1168 | 503 }else |
504 assert(0); | |
3315 | 505 assert(h==4); |
1168 | 506 } |
507 | |
3028 | 508 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 509 MpegEncContext * const s = &h->s; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
510 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 511 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
512 int topleft_type, top_type, topright_type, left_type[2]; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
513 int left_block[8]; |
1168 | 514 int i; |
515 | |
3482 | 516 //FIXME deblocking could skip the intra and nnz parts. |
517 if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[mb_xy-s->mb_stride]) && !FRAME_MBAFF) | |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
518 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
519 |
2967 | 520 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
521 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
522 top_xy = mb_xy - s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
523 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
524 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
525 left_xy[1] = left_xy[0] = mb_xy-1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
526 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
527 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
528 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
529 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
530 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
531 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
532 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
533 left_block[7]= 11; |
3316 | 534 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
535 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
536 const int top_pair_xy = pair_xy - s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
537 const int topleft_pair_xy = top_pair_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
538 const int topright_pair_xy = top_pair_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
539 const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
540 const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
541 const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
542 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
543 const int curr_mb_frame_flag = !IS_INTERLACED(mb_type); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
544 const int bottom = (s->mb_y & 1); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
545 tprintf("fill_caches: curr_mb_frame_flag:%d, left_mb_frame_flag:%d, topleft_mb_frame_flag:%d, top_mb_frame_flag:%d, topright_mb_frame_flag:%d\n", curr_mb_frame_flag, left_mb_frame_flag, topleft_mb_frame_flag, top_mb_frame_flag, topright_mb_frame_flag); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
546 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
547 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
548 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
549 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
550 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
551 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
552 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
553 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
554 : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
555 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
556 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
557 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
558 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
559 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
560 : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
561 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
562 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
563 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
564 if (left_mb_frame_flag != curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
565 left_xy[1] = left_xy[0] = pair_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
566 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
567 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
568 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
569 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
570 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
571 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
572 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
573 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
574 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
575 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
576 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
577 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
578 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
579 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
580 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
581 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
582 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
583 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
584 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
585 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
586 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
587 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
588 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
589 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
590 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
591 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
592 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
593 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
594 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
595 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
596 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
597 } |
1168 | 598 } |
599 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
600 h->top_mb_xy = top_xy; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
601 h->left_mb_xy[0] = left_xy[0]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
602 h->left_mb_xy[1] = left_xy[1]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
603 if(for_deblock){ |
3482 | 604 topleft_type = 0; |
605 topright_type = 0; | |
2449 | 606 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
607 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
608 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 609 |
610 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
611 int list; | |
612 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
613 for(i=0; i<16; i++) | |
614 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
615 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ | |
616 if(USES_LIST(mb_type,list)){ | |
617 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
618 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 619 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 620 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
621 dst[0] = src[0]; | |
622 dst[1] = src[1]; | |
623 dst[2] = src[2]; | |
624 dst[3] = src[3]; | |
625 } | |
626 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
627 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
628 ref += h->b8_stride; | |
629 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
630 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
631 }else{ | |
632 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
633 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
634 } | |
635 } | |
636 } | |
2449 | 637 }else{ |
638 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
639 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
640 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
641 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
642 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
643 } | |
1168 | 644 |
645 if(IS_INTRA(mb_type)){ | |
2967 | 646 h->topleft_samples_available= |
647 h->top_samples_available= | |
1168 | 648 h->left_samples_available= 0xFFFF; |
649 h->topright_samples_available= 0xEEEA; | |
650 | |
651 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
652 h->topleft_samples_available= 0xB3FF; | |
653 h->top_samples_available= 0x33FF; | |
654 h->topright_samples_available= 0x26EA; | |
655 } | |
656 for(i=0; i<2; i++){ | |
657 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
658 h->topleft_samples_available&= 0xDF5F; | |
659 h->left_samples_available&= 0x5F5F; | |
660 } | |
661 } | |
2967 | 662 |
1168 | 663 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
664 h->topleft_samples_available&= 0x7FFF; | |
2967 | 665 |
1168 | 666 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
667 h->topright_samples_available&= 0xFBFF; | |
2967 | 668 |
1168 | 669 if(IS_INTRA4x4(mb_type)){ |
670 if(IS_INTRA4x4(top_type)){ | |
671 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
672 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
673 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
674 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
675 }else{ | |
676 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
677 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
678 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
679 else{ |
1168 | 680 pred= 2; |
681 } | |
682 h->intra4x4_pred_mode_cache[4+8*0]= | |
683 h->intra4x4_pred_mode_cache[5+8*0]= | |
684 h->intra4x4_pred_mode_cache[6+8*0]= | |
685 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
686 } | |
687 for(i=0; i<2; i++){ | |
688 if(IS_INTRA4x4(left_type[i])){ | |
689 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
690 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
691 }else{ | |
692 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
693 if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
694 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
695 else{ |
1168 | 696 pred= 2; |
697 } | |
698 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
699 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
700 } | |
701 } | |
702 } | |
703 } | |
2967 | 704 |
705 | |
1168 | 706 /* |
2967 | 707 0 . T T. T T T T |
708 1 L . .L . . . . | |
709 2 L . .L . . . . | |
710 3 . T TL . . . . | |
711 4 L . .L . . . . | |
712 5 L . .. . . . . | |
1168 | 713 */ |
714 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
715 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
716 h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
717 h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
718 h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
719 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 720 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
721 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
722 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 723 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
724 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
725 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 726 |
1168 | 727 }else{ |
2967 | 728 h->non_zero_count_cache[4+8*0]= |
1168 | 729 h->non_zero_count_cache[5+8*0]= |
730 h->non_zero_count_cache[6+8*0]= | |
731 h->non_zero_count_cache[7+8*0]= | |
2967 | 732 |
1168 | 733 h->non_zero_count_cache[1+8*0]= |
734 h->non_zero_count_cache[2+8*0]= | |
2967 | 735 |
1168 | 736 h->non_zero_count_cache[1+8*3]= |
2314 | 737 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 738 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
739 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
740 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
741 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
742 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
743 h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
744 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
745 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
746 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
747 }else{ |
2967 | 748 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
749 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
750 h->non_zero_count_cache[0+8*1 + 8*i]= | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
751 h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
752 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
753 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
754 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
755 if( h->pps.cabac ) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
756 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
757 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
758 h->top_cbp = h->cbp_table[top_xy]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
759 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
760 h->top_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
761 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
762 h->top_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
763 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
764 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
765 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
766 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
767 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
768 h->left_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
769 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
770 h->left_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
771 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
772 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
773 h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
774 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
775 if (left_type[1]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
776 h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
777 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
778 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
779 |
1168 | 780 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
781 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 782 int list; |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
783 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
784 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 785 /*if(!h->mv_cache_clean[list]){ |
786 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
787 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
788 h->mv_cache_clean[list]= 1; | |
789 }*/ | |
2396 | 790 continue; |
1168 | 791 } |
792 h->mv_cache_clean[list]= 0; | |
2967 | 793 |
3212 | 794 if(USES_LIST(top_type, list)){ |
1168 | 795 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
796 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
797 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
798 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
799 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
800 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
801 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
802 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
803 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
804 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
805 }else{ | |
2967 | 806 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
807 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
808 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 809 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
810 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
811 } | |
812 | |
813 //FIXME unify cleanup or sth | |
3212 | 814 if(USES_LIST(left_type[0], list)){ |
1168 | 815 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
816 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1; | |
817 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]]; | |
818 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1]]; | |
3316 | 819 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)]; |
820 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1]>>1)]; | |
1168 | 821 }else{ |
822 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]= | |
823 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0; | |
824 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
825 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
826 } | |
2967 | 827 |
3212 | 828 if(USES_LIST(left_type[1], list)){ |
1168 | 829 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
830 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1; | |
831 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[2]]; | |
832 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[3]]; | |
3316 | 833 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)]; |
834 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[3]>>1)]; | |
1168 | 835 }else{ |
836 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]= | |
837 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0; | |
838 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
839 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
2669 | 840 assert((!left_type[0]) == (!left_type[1])); |
1168 | 841 } |
842 | |
3519 | 843 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 844 continue; |
845 | |
3212 | 846 if(USES_LIST(topleft_type, list)){ |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
847 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
848 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
849 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
850 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
851 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
852 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
853 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
854 } |
2967 | 855 |
3212 | 856 if(USES_LIST(topright_type, list)){ |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
857 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
858 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
859 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
860 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
861 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
862 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
863 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
864 } |
2967 | 865 |
3519 | 866 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 867 continue; |
2967 | 868 |
869 h->ref_cache[list][scan8[5 ]+1] = | |
870 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
871 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 872 h->ref_cache[list][scan8[4 ]] = |
1168 | 873 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
874 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
875 *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]= | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
876 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 877 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
878 *(uint32_t*)h->mv_cache [list][scan8[12]]= 0; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
879 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
880 if( h->pps.cabac ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
881 /* XXX beurk, Load mvd */ |
3212 | 882 if(USES_LIST(top_type, list)){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
883 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
884 *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
885 *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
886 *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
887 *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
888 }else{ |
2967 | 889 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
890 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
891 *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]= | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
892 *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
893 } |
3212 | 894 if(USES_LIST(left_type[0], list)){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
895 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
896 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
897 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
898 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
899 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
900 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
901 } |
3212 | 902 if(USES_LIST(left_type[1], list)){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
903 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
904 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
905 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
906 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
907 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
908 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
909 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
910 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
911 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]= |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
912 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
913 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
914 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 915 |
916 if(h->slice_type == B_TYPE){ | |
917 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
918 | |
919 if(IS_DIRECT(top_type)){ | |
920 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
921 }else if(IS_8X8(top_type)){ | |
922 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
923 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
924 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
925 }else{ | |
926 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
927 } | |
2967 | 928 |
3316 | 929 if(IS_DIRECT(left_type[0])) |
930 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
931 else if(IS_8X8(left_type[0])) | |
932 h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)]; | |
933 else | |
934 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
935 | |
936 if(IS_DIRECT(left_type[1])) | |
2396 | 937 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 938 else if(IS_8X8(left_type[1])) |
939 h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)]; | |
940 else | |
2396 | 941 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 942 } |
943 } | |
944 | |
945 if(FRAME_MBAFF){ | |
946 #define MAP_MVS\ | |
947 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
948 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
949 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
950 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
951 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
952 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
953 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
954 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
955 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
956 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
957 if(MB_FIELD){ | |
958 #define MAP_F2F(idx, mb_type)\ | |
959 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
960 h->ref_cache[list][idx] <<= 1;\ | |
961 h->mv_cache[list][idx][1] /= 2;\ | |
962 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 963 } |
3316 | 964 MAP_MVS |
965 #undef MAP_F2F | |
966 }else{ | |
967 #define MAP_F2F(idx, mb_type)\ | |
968 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
969 h->ref_cache[list][idx] >>= 1;\ | |
970 h->mv_cache[list][idx][1] <<= 1;\ | |
971 h->mvd_cache[list][idx][1] <<= 1;\ | |
972 } | |
973 MAP_MVS | |
974 #undef MAP_F2F | |
2396 | 975 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
976 } |
1168 | 977 } |
978 } | |
979 #endif | |
2755 | 980 |
981 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 982 } |
983 | |
984 static inline void write_back_intra_pred_mode(H264Context *h){ | |
985 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
986 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 987 |
988 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
989 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
990 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
991 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
992 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
993 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
994 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
995 } | |
996 | |
997 /** | |
998 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
999 */ | |
1000 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
1001 MpegEncContext * const s = &h->s; | |
1002 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
1003 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
1004 int i; | |
2967 | 1005 |
1168 | 1006 if(!(h->top_samples_available&0x8000)){ |
1007 for(i=0; i<4; i++){ | |
1008 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
1009 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1010 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 1011 return -1; |
1012 } else if(status){ | |
1013 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
1014 } | |
1015 } | |
1016 } | |
2967 | 1017 |
1168 | 1018 if(!(h->left_samples_available&0x8000)){ |
1019 for(i=0; i<4; i++){ | |
1020 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
1021 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1022 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 1023 return -1; |
1024 } else if(status){ | |
1025 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
1026 } | |
1027 } | |
1028 } | |
1029 | |
1030 return 0; | |
1031 } //FIXME cleanup like next | |
1032 | |
1033 /** | |
1034 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1035 */ | |
1036 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
1037 MpegEncContext * const s = &h->s; | |
1038 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
1039 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 1040 |
2392 | 1041 if(mode < 0 || mode > 6) { |
1042 av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y); | |
2163 | 1043 return -1; |
2392 | 1044 } |
2967 | 1045 |
1168 | 1046 if(!(h->top_samples_available&0x8000)){ |
1047 mode= top[ mode ]; | |
1048 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1049 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); |
1168 | 1050 return -1; |
1051 } | |
1052 } | |
2967 | 1053 |
1168 | 1054 if(!(h->left_samples_available&0x8000)){ |
1055 mode= left[ mode ]; | |
1056 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1057 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); |
1168 | 1058 return -1; |
2967 | 1059 } |
1168 | 1060 } |
1061 | |
1062 return mode; | |
1063 } | |
1064 | |
1065 /** | |
1066 * gets the predicted intra4x4 prediction mode. | |
1067 */ | |
1068 static inline int pred_intra_mode(H264Context *h, int n){ | |
1069 const int index8= scan8[n]; | |
1070 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1071 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1072 const int min= FFMIN(left, top); | |
1073 | |
1170 | 1074 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 1075 |
1076 if(min<0) return DC_PRED; | |
1077 else return min; | |
1078 } | |
1079 | |
1080 static inline void write_back_non_zero_count(H264Context *h){ | |
1081 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
1082 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
1083 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1084 h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1085 h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1086 h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
1087 h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4]; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1088 h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1089 h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1090 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 1091 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1092 h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
1093 h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2]; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1094 h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1095 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1096 h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
1097 h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5]; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1098 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 1099 |
1100 if(FRAME_MBAFF){ | |
1101 // store all luma nnzs, for deblocking | |
1102 int v = 0, i; | |
1103 for(i=0; i<16; i++) | |
1104 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
1105 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
1106 } | |
1168 | 1107 } |
1108 | |
1109 /** | |
1110 * gets the predicted number of non zero coefficients. | |
1111 * @param n block index | |
1112 */ | |
1113 static inline int pred_non_zero_count(H264Context *h, int n){ | |
1114 const int index8= scan8[n]; | |
1115 const int left= h->non_zero_count_cache[index8 - 1]; | |
1116 const int top = h->non_zero_count_cache[index8 - 8]; | |
1117 int i= left + top; | |
2967 | 1118 |
1168 | 1119 if(i<64) i= (i+1)>>1; |
1120 | |
1170 | 1121 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 1122 |
1123 return i&31; | |
1124 } | |
1125 | |
1169 | 1126 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
1127 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
1128 | |
3316 | 1129 /* there is no consistent mapping of mvs to neighboring locations that will |
1130 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
1131 if(FRAME_MBAFF){ | |
1132 MpegEncContext *s = &h->s; | |
3776 | 1133 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 1134 const int16_t *mv; |
1135 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
1136 *C = h->mv_cache[list][scan8[0]-2]; | |
1137 | |
1138 if(!MB_FIELD | |
1139 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
1140 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
1141 if(IS_INTERLACED(mb_types[topright_xy])){ | |
1142 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
1143 const int x4 = X4, y4 = Y4;\ | |
1144 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
1145 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
1146 return LIST_NOT_USED;\ | |
1147 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
1148 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
1149 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
1150 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
1151 | |
1152 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
1153 } | |
1154 } | |
1155 if(topright_ref == PART_NOT_AVAILABLE | |
1156 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
1157 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
1158 if(!MB_FIELD | |
1159 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
1160 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
1161 } | |
1162 if(MB_FIELD | |
1163 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
1164 && i >= scan8[0]+8){ | |
1165 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
1166 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
1167 } | |
1168 } | |
1169 #undef SET_DIAG_MV | |
1170 } | |
1171 | |
1169 | 1172 if(topright_ref != PART_NOT_AVAILABLE){ |
1173 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
1174 return topright_ref; | |
1175 }else{ | |
1170 | 1176 tprintf("topright MV not available\n"); |
1177 | |
1169 | 1178 *C= h->mv_cache[list][ i - 8 - 1 ]; |
1179 return h->ref_cache[list][ i - 8 - 1 ]; | |
1180 } | |
1181 } | |
1182 | |
1168 | 1183 /** |
1184 * gets the predicted MV. | |
1185 * @param n the block index | |
1186 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
1187 * @param mx the x component of the predicted motion vector | |
1188 * @param my the y component of the predicted motion vector | |
1189 */ | |
1190 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
1191 const int index8= scan8[n]; | |
1192 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
1193 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
1194 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
1195 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 1196 const int16_t * C; |
1197 int diagonal_ref, match_count; | |
1198 | |
1168 | 1199 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 1200 |
1168 | 1201 /* mv_cache |
2967 | 1202 B . . A T T T T |
1168 | 1203 U . . L . . , . |
1204 U . . L . . . . | |
1205 U . . L . . , . | |
1206 . . . L . . . . | |
1207 */ | |
1169 | 1208 |
1209 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
1210 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref); | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
1211 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 1212 if(match_count > 1){ //most common |
1213 *mx= mid_pred(A[0], B[0], C[0]); | |
1214 *my= mid_pred(A[1], B[1], C[1]); | |
1215 }else if(match_count==1){ | |
1216 if(left_ref==ref){ | |
1217 *mx= A[0]; | |
2967 | 1218 *my= A[1]; |
1169 | 1219 }else if(top_ref==ref){ |
1220 *mx= B[0]; | |
2967 | 1221 *my= B[1]; |
1169 | 1222 }else{ |
1223 *mx= C[0]; | |
2967 | 1224 *my= C[1]; |
1169 | 1225 } |
1226 }else{ | |
1227 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
1228 *mx= A[0]; | |
2967 | 1229 *my= A[1]; |
1168 | 1230 }else{ |
1231 *mx= mid_pred(A[0], B[0], C[0]); | |
1232 *my= mid_pred(A[1], B[1], C[1]); | |
1233 } | |
1169 | 1234 } |
2967 | 1235 |
1187 | 1236 tprintf("pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1237 } |
1238 | |
1239 /** | |
1240 * gets the directionally predicted 16x8 MV. | |
1241 * @param n the block index | |
1242 * @param mx the x component of the predicted motion vector | |
1243 * @param my the y component of the predicted motion vector | |
1244 */ | |
1245 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1246 if(n==0){ | |
1247 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
1248 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
1249 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1250 tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list); |
2967 | 1251 |
1168 | 1252 if(top_ref == ref){ |
1253 *mx= B[0]; | |
1254 *my= B[1]; | |
1255 return; | |
1256 } | |
1257 }else{ | |
1258 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
1259 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 1260 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1261 tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1262 |
1263 if(left_ref == ref){ | |
1264 *mx= A[0]; | |
1265 *my= A[1]; | |
1266 return; | |
1267 } | |
1268 } | |
1269 | |
1270 //RARE | |
1271 pred_motion(h, n, 4, list, ref, mx, my); | |
1272 } | |
1273 | |
1274 /** | |
1275 * gets the directionally predicted 8x16 MV. | |
1276 * @param n the block index | |
1277 * @param mx the x component of the predicted motion vector | |
1278 * @param my the y component of the predicted motion vector | |
1279 */ | |
1280 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1281 if(n==0){ | |
1282 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1283 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 1284 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1285 tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1286 |
1287 if(left_ref == ref){ | |
1288 *mx= A[0]; | |
1289 *my= A[1]; | |
1290 return; | |
1291 } | |
1292 }else{ | |
1169 | 1293 const int16_t * C; |
1294 int diagonal_ref; | |
1295 | |
1296 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 1297 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1298 tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1299 |
2967 | 1300 if(diagonal_ref == ref){ |
1168 | 1301 *mx= C[0]; |
1302 *my= C[1]; | |
1303 return; | |
1304 } | |
1305 } | |
1306 | |
1307 //RARE | |
1308 pred_motion(h, n, 2, list, ref, mx, my); | |
1309 } | |
1310 | |
1311 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1312 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1313 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1314 | |
2392 | 1315 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1316 |
1317 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1318 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1319 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 1320 |
1168 | 1321 *mx = *my = 0; |
1322 return; | |
1323 } | |
2967 | 1324 |
1168 | 1325 pred_motion(h, 0, 4, 0, 0, mx, my); |
1326 | |
1327 return; | |
1328 } | |
1329 | |
2396 | 1330 static inline void direct_dist_scale_factor(H264Context * const h){ |
1331 const int poc = h->s.current_picture_ptr->poc; | |
1332 const int poc1 = h->ref_list[1][0].poc; | |
1333 int i; | |
1334 for(i=0; i<h->ref_count[0]; i++){ | |
1335 int poc0 = h->ref_list[0][i].poc; | |
1336 int td = clip(poc1 - poc0, -128, 127); | |
1337 if(td == 0 /* FIXME || pic0 is a long-term ref */){ | |
1338 h->dist_scale_factor[i] = 256; | |
1339 }else{ | |
1340 int tb = clip(poc - poc0, -128, 127); | |
4001 | 1341 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2396 | 1342 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023); |
1343 } | |
1344 } | |
3316 | 1345 if(FRAME_MBAFF){ |
1346 for(i=0; i<h->ref_count[0]; i++){ | |
1347 h->dist_scale_factor_field[2*i] = | |
1348 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
1349 } | |
1350 } | |
2396 | 1351 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1352 static inline void direct_ref_list_init(H264Context * const h){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1353 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1354 Picture * const ref1 = &h->ref_list[1][0]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1355 Picture * const cur = s->current_picture_ptr; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1356 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1357 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1358 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1359 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1360 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1361 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1362 cur->ref_count[list] = h->ref_count[list]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1363 for(j=0; j<h->ref_count[list]; j++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1364 cur->ref_poc[list][j] = h->ref_list[list][j].poc; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1365 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1366 if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1367 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1368 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1369 for(i=0; i<ref1->ref_count[list]; i++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1370 const int poc = ref1->ref_poc[list][i]; |
3125 | 1371 h->map_col_to_list0[list][i] = 0; /* bogus; fills in for missing frames */ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1372 for(j=0; j<h->ref_count[list]; j++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1373 if(h->ref_list[list][j].poc == poc){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1374 h->map_col_to_list0[list][i] = j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1375 break; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1376 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1377 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1378 } |
3316 | 1379 if(FRAME_MBAFF){ |
1380 for(list=0; list<2; list++){ | |
1381 for(i=0; i<ref1->ref_count[list]; i++){ | |
1382 j = h->map_col_to_list0[list][i]; | |
1383 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1384 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1385 } | |
1386 } | |
1387 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1388 } |
2396 | 1389 |
1390 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1391 MpegEncContext * const s = &h->s; | |
1392 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1393 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1394 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1395 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1396 const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy]; | |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1397 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1398 const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1399 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1400 const int is_b8x8 = IS_8X8(*mb_type); |
1401 int sub_mb_type; | |
1402 int i8, i4; | |
1403 | |
3316 | 1404 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1405 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1406 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1407 * so we know exactly what block size to use */ | |
1408 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1409 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1410 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1411 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1412 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1413 }else{ | |
1414 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1415 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1416 } |
1417 if(!is_b8x8) | |
1418 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1419 if(MB_FIELD) |
1420 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1421 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
1422 tprintf("mb_type = %08x, sub_mb_type = %08x, is_b8x8 = %d, mb_type_col = %08x\n", *mb_type, sub_mb_type, is_b8x8, mb_type_col); |
2967 | 1423 |
2396 | 1424 if(h->direct_spatial_mv_pred){ |
1425 int ref[2]; | |
1426 int mv[2][2]; | |
1427 int list; | |
1428 | |
3316 | 1429 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1430 | |
2396 | 1431 /* ref = min(neighbors) */ |
1432 for(list=0; list<2; list++){ | |
1433 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1434 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1435 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1436 if(refc == -2) | |
1437 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1438 ref[list] = refa; | |
1439 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1440 ref[list] = refb; | |
1441 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1442 ref[list] = refc; | |
1443 if(ref[list] < 0) | |
1444 ref[list] = -1; | |
1445 } | |
1446 | |
1447 if(ref[0] < 0 && ref[1] < 0){ | |
1448 ref[0] = ref[1] = 0; | |
1449 mv[0][0] = mv[0][1] = | |
1450 mv[1][0] = mv[1][1] = 0; | |
1451 }else{ | |
1452 for(list=0; list<2; list++){ | |
1453 if(ref[list] >= 0) | |
1454 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1455 else | |
1456 mv[list][0] = mv[list][1] = 0; | |
1457 } | |
1458 } | |
1459 | |
1460 if(ref[1] < 0){ | |
1461 *mb_type &= ~MB_TYPE_P0L1; | |
1462 sub_mb_type &= ~MB_TYPE_P0L1; | |
1463 }else if(ref[0] < 0){ | |
1464 *mb_type &= ~MB_TYPE_P0L0; | |
1465 sub_mb_type &= ~MB_TYPE_P0L0; | |
1466 } | |
1467 | |
1468 if(IS_16X16(*mb_type)){ | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1469 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1); |
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1470 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1471 if(!IS_INTRA(mb_type_col) |
4001 | 1472 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1473 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1474 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1475 if(ref[0] > 0) |
1476 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1477 else | |
1478 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1479 if(ref[1] > 0) | |
1480 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1481 else | |
1482 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1483 }else{ | |
1484 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1485 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1486 } | |
1487 }else{ | |
1488 for(i8=0; i8<4; i8++){ | |
1489 const int x8 = i8&1; | |
1490 const int y8 = i8>>1; | |
2967 | 1491 |
2396 | 1492 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1493 continue; | |
1494 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1495 |
2396 | 1496 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1497 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1498 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1); |
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1499 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1500 |
2396 | 1501 /* col_zero_flag */ |
2967 | 1502 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1503 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1504 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1505 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1506 if(IS_SUB_8X8(sub_mb_type)){ |
1507 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1508 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1509 if(ref[0] == 0) |
1510 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1511 if(ref[1] == 0) | |
1512 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1513 } | |
1514 }else | |
2396 | 1515 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1516 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1517 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1518 if(ref[0] == 0) |
1519 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1520 if(ref[1] == 0) | |
1521 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1522 } | |
1523 } | |
1524 } | |
1525 } | |
1526 } | |
1527 }else{ /* direct temporal mv pred */ | |
3316 | 1528 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1529 const int *dist_scale_factor = h->dist_scale_factor; | |
1530 | |
1531 if(FRAME_MBAFF){ | |
1532 if(IS_INTERLACED(*mb_type)){ | |
1533 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1534 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1535 dist_scale_factor = h->dist_scale_factor_field; | |
1536 } | |
1537 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1538 /* FIXME assumes direct_8x8_inference == 1 */ | |
1539 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1540 int mb_types_col[2]; | |
1541 int y_shift; | |
1542 | |
1543 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1544 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1545 | (*mb_type & MB_TYPE_INTERLACED); | |
1546 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1547 | |
1548 if(IS_INTERLACED(*mb_type)){ | |
1549 /* frame to field scaling */ | |
1550 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1551 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1552 if(s->mb_y&1){ | |
1553 l1ref0 -= 2*h->b8_stride; | |
1554 l1ref1 -= 2*h->b8_stride; | |
1555 l1mv0 -= 4*h->b_stride; | |
1556 l1mv1 -= 4*h->b_stride; | |
1557 } | |
1558 y_shift = 0; | |
1559 | |
1560 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1561 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1562 && !is_b8x8) | |
1563 *mb_type |= MB_TYPE_16x8; | |
1564 else | |
1565 *mb_type |= MB_TYPE_8x8; | |
1566 }else{ | |
1567 /* field to frame scaling */ | |
1568 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1569 * but in MBAFF, top and bottom POC are equal */ | |
1570 int dy = (s->mb_y&1) ? 1 : 2; | |
1571 mb_types_col[0] = | |
1572 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1573 l1ref0 += dy*h->b8_stride; | |
1574 l1ref1 += dy*h->b8_stride; | |
1575 l1mv0 += 2*dy*h->b_stride; | |
1576 l1mv1 += 2*dy*h->b_stride; | |
1577 y_shift = 2; | |
1578 | |
1579 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1580 && !is_b8x8) | |
1581 *mb_type |= MB_TYPE_16x16; | |
1582 else | |
1583 *mb_type |= MB_TYPE_8x8; | |
1584 } | |
1585 | |
1586 for(i8=0; i8<4; i8++){ | |
1587 const int x8 = i8&1; | |
1588 const int y8 = i8>>1; | |
1589 int ref0, scale; | |
1590 const int16_t (*l1mv)[2]= l1mv0; | |
1591 | |
1592 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1593 continue; | |
1594 h->sub_mb_type[i8] = sub_mb_type; | |
1595 | |
1596 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1597 if(IS_INTRA(mb_types_col[y8])){ | |
1598 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1599 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1600 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1601 continue; | |
1602 } | |
1603 | |
1604 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1605 if(ref0 >= 0) | |
1606 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1607 else{ | |
1608 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1609 l1mv= l1mv1; | |
1610 } | |
1611 scale = dist_scale_factor[ref0]; | |
1612 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1613 | |
1614 { | |
1615 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1616 int my_col = (mv_col[1]<<y_shift)/2; | |
1617 int mx = (scale * mv_col[0] + 128) >> 8; | |
1618 int my = (scale * my_col + 128) >> 8; | |
1619 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1620 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1621 } | |
1622 } | |
1623 return; | |
1624 } | |
1625 } | |
1626 | |
1627 /* one-to-one mv scaling */ | |
1628 | |
2396 | 1629 if(IS_16X16(*mb_type)){ |
1630 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); | |
1631 if(IS_INTRA(mb_type_col)){ | |
1632 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1633 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1634 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1635 }else{ | |
3316 | 1636 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1637 : map_col_to_list0[1][l1ref1[0]]; | |
1638 const int scale = dist_scale_factor[ref0]; | |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1639 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1640 int mv_l0[2]; |
3316 | 1641 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1642 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1643 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1); |
1644 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4); | |
1645 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]), 4); | |
1646 } | |
1647 }else{ | |
1648 for(i8=0; i8<4; i8++){ | |
1649 const int x8 = i8&1; | |
1650 const int y8 = i8>>1; | |
3316 | 1651 int ref0, scale; |
2834 | 1652 const int16_t (*l1mv)[2]= l1mv0; |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1653 |
2396 | 1654 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1655 continue; | |
1656 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1657 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1658 if(IS_INTRA(mb_type_col)){ |
1659 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1660 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1661 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1662 continue; | |
1663 } | |
2967 | 1664 |
2396 | 1665 ref0 = l1ref0[x8 + y8*h->b8_stride]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1666 if(ref0 >= 0) |
3316 | 1667 ref0 = map_col_to_list0[0][ref0]; |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1668 else{ |
3316 | 1669 ref0 = map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]]; |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1670 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1671 } |
3316 | 1672 scale = dist_scale_factor[ref0]; |
2967 | 1673 |
2396 | 1674 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1675 if(IS_SUB_8X8(sub_mb_type)){ |
1676 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1677 int mx = (scale * mv_col[0] + 128) >> 8; |
1678 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1679 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1680 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1681 }else | |
2396 | 1682 for(i4=0; i4<4; i4++){ |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1683 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1684 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1685 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1686 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1687 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1688 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1689 } | |
1690 } | |
1691 } | |
1692 } | |
1693 } | |
1694 | |
1168 | 1695 static inline void write_back_motion(H264Context *h, int mb_type){ |
1696 MpegEncContext * const s = &h->s; | |
1697 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1698 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1699 int list; | |
1700 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1701 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1702 fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1); |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1703 |
1168 | 1704 for(list=0; list<2; list++){ |
1705 int y; | |
3212 | 1706 if(!USES_LIST(mb_type, list)) |
2396 | 1707 continue; |
2967 | 1708 |
1168 | 1709 for(y=0; y<4; y++){ |
1710 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y]; | |
1711 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y]; | |
1712 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1713 if( h->pps.cabac ) { |
3927 | 1714 if(IS_SKIP(mb_type)) |
1715 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1716 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1717 for(y=0; y<4; y++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1718 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1719 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1720 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1721 } |
3212 | 1722 |
1723 { | |
3776 | 1724 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1725 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1726 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1727 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1728 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1729 } |
1730 } | |
2967 | 1731 |
2396 | 1732 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1733 if(IS_8X8(mb_type)){ | |
3212 | 1734 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1735 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1736 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1737 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1738 } |
1739 } | |
1168 | 1740 } |
1741 | |
1742 /** | |
1743 * Decodes a network abstraction layer unit. | |
1744 * @param consumed is the number of bytes used as input | |
1745 * @param length is the length of the array | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1746 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1747 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1748 */ |
1749 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1750 int i, si, di; | |
1751 uint8_t *dst; | |
1752 | |
2979 | 1753 // src[0]&0x80; //forbidden bit |
1168 | 1754 h->nal_ref_idc= src[0]>>5; |
1755 h->nal_unit_type= src[0]&0x1F; | |
1756 | |
1757 src++; length--; | |
2967 | 1758 #if 0 |
1168 | 1759 for(i=0; i<length; i++) |
1760 printf("%2X ", src[i]); | |
1761 #endif | |
1762 for(i=0; i+1<length; i+=2){ | |
1763 if(src[i]) continue; | |
1764 if(i>0 && src[i-1]==0) i--; | |
1765 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1766 if(src[i+2]!=3){ | |
1767 /* startcode, so we must be past the end */ | |
1768 length=i; | |
1769 } | |
1770 break; | |
1771 } | |
1772 } | |
1773 | |
1774 if(i>=length-1){ //no escaped 0 | |
1775 *dst_length= length; | |
1776 *consumed= length+1; //+1 for the header | |
2967 | 1777 return src; |
1168 | 1778 } |
1779 | |
1780 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1781 dst= h->rbsp_buffer; | |
1782 | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1783 if (dst == NULL){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1784 return NULL; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1785 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1786 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1787 //printf("decoding esc\n"); |
1168 | 1788 si=di=0; |
2967 | 1789 while(si<length){ |
1168 | 1790 //remove escapes (very rare 1:2^22) |
1791 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1792 if(src[si+2]==3){ //escape | |
1793 dst[di++]= 0; | |
1794 dst[di++]= 0; | |
1795 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1796 continue; |
1168 | 1797 }else //next start code |
1798 break; | |
1799 } | |
1800 | |
1801 dst[di++]= src[si++]; | |
1802 } | |
1803 | |
1804 *dst_length= di; | |
1805 *consumed= si + 1;//+1 for the header | |
1806 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1807 return dst; | |
1808 } | |
1809 | |
1810 /** | |
1811 * identifies the exact end of the bitstream | |
1812 * @return the length of the trailing, or 0 if damaged | |
1813 */ | |
1814 static int decode_rbsp_trailing(uint8_t *src){ | |
1815 int v= *src; | |
1816 int r; | |
1817 | |
1170 | 1818 tprintf("rbsp trailing %X\n", v); |
1168 | 1819 |
1820 for(r=1; r<9; r++){ | |
1821 if(v&1) return r; | |
1822 v>>=1; | |
1823 } | |
1824 return 0; | |
1825 } | |
1826 | |
1827 /** | |
1828 * idct tranforms the 16 dc values and dequantize them. | |
1829 * @param qp quantization parameter | |
1830 */ | |
2919 | 1831 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1832 #define stride 16 |
1833 int i; | |
1834 int temp[16]; //FIXME check if this is a good idea | |
1835 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1836 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1837 | |
1838 //memset(block, 64, 2*256); | |
1839 //return; | |
1840 for(i=0; i<4; i++){ | |
1841 const int offset= y_offset[i]; | |
1842 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1843 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1844 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1845 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1846 | |
1847 temp[4*i+0]= z0+z3; | |
1848 temp[4*i+1]= z1+z2; | |
1849 temp[4*i+2]= z1-z2; | |
1850 temp[4*i+3]= z0-z3; | |
1851 } | |
1852 | |
1853 for(i=0; i<4; i++){ | |
1854 const int offset= x_offset[i]; | |
1855 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1856 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1857 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1858 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1859 | |
2919 | 1860 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1861 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1862 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1863 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1864 } |
1865 } | |
1866 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1867 #if 0 |
1168 | 1868 /** |
1869 * dct tranforms the 16 dc values. | |
1870 * @param qp quantization parameter ??? FIXME | |
1871 */ | |
1872 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1873 // const int qmul= dequant_coeff[qp][0]; | |
1874 int i; | |
1875 int temp[16]; //FIXME check if this is a good idea | |
1876 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1877 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1878 | |
1879 for(i=0; i<4; i++){ | |
1880 const int offset= y_offset[i]; | |
1881 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1882 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1883 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1884 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1885 | |
1886 temp[4*i+0]= z0+z3; | |
1887 temp[4*i+1]= z1+z2; | |
1888 temp[4*i+2]= z1-z2; | |
1889 temp[4*i+3]= z0-z3; | |
1890 } | |
1891 | |
1892 for(i=0; i<4; i++){ | |
1893 const int offset= x_offset[i]; | |
1894 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1895 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1896 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1897 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1898 | |
1899 block[stride*0 +offset]= (z0 + z3)>>1; | |
1900 block[stride*2 +offset]= (z1 + z2)>>1; | |
1901 block[stride*8 +offset]= (z1 - z2)>>1; | |
1902 block[stride*10+offset]= (z0 - z3)>>1; | |
1903 } | |
1904 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1905 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1906 |
1168 | 1907 #undef xStride |
1908 #undef stride | |
1909 | |
2919 | 1910 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1911 const int stride= 16*2; |
1912 const int xStride= 16; | |
1913 int a,b,c,d,e; | |
1914 | |
1915 a= block[stride*0 + xStride*0]; | |
1916 b= block[stride*0 + xStride*1]; | |
1917 c= block[stride*1 + xStride*0]; | |
1918 d= block[stride*1 + xStride*1]; | |
1919 | |
1920 e= a-b; | |
1921 a= a+b; | |
1922 b= c-d; | |
1923 c= c+d; | |
1924 | |
2919 | 1925 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1926 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1927 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1928 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1929 } |
1930 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1931 #if 0 |
1168 | 1932 static void chroma_dc_dct_c(DCTELEM *block){ |
1933 const int stride= 16*2; | |
1934 const int xStride= 16; | |
1935 int a,b,c,d,e; | |
1936 | |
1937 a= block[stride*0 + xStride*0]; | |
1938 b= block[stride*0 + xStride*1]; | |
1939 c= block[stride*1 + xStride*0]; | |
1940 d= block[stride*1 + xStride*1]; | |
1941 | |
1942 e= a-b; | |
1943 a= a+b; | |
1944 b= c-d; | |
1945 c= c+d; | |
1946 | |
1947 block[stride*0 + xStride*0]= (a+c); | |
1948 block[stride*0 + xStride*1]= (e+b); | |
1949 block[stride*1 + xStride*0]= (a-c); | |
1950 block[stride*1 + xStride*1]= (e-b); | |
1951 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1952 #endif |
1168 | 1953 |
1954 /** | |
1955 * gets the chroma qp. | |
1956 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1957 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 1958 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1959 return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 1960 } |
1961 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1962 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close |
1168 | 1963 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away) |
1964 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){ | |
1965 int i; | |
1966 const int * const quant_table= quant_coeff[qscale]; | |
1967 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1968 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1969 const unsigned int threshold2= (threshold1<<1); | |
1970 int last_non_zero; | |
1971 | |
1972 if(seperate_dc){ | |
1973 if(qscale<=18){ | |
1974 //avoid overflows | |
1975 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1976 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1977 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1978 | |
1979 int level= block[0]*quant_coeff[qscale+18][0]; | |
1980 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1981 if(level>0){ | |
1982 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1983 block[0]= level; | |
1984 }else{ | |
1985 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1986 block[0]= -level; | |
1987 } | |
1988 // last_non_zero = i; | |
1989 }else{ | |
1990 block[0]=0; | |
1991 } | |
1992 }else{ | |
1993 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1994 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1995 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1996 | |
1997 int level= block[0]*quant_table[0]; | |
1998 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1999 if(level>0){ | |
2000 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
2001 block[0]= level; | |
2002 }else{ | |
2003 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
2004 block[0]= -level; | |
2005 } | |
2006 // last_non_zero = i; | |
2007 }else{ | |
2008 block[0]=0; | |
2009 } | |
2010 } | |
2011 last_non_zero= 0; | |
2012 i=1; | |
2013 }else{ | |
2014 last_non_zero= -1; | |
2015 i=0; | |
2016 } | |
2017 | |
2018 for(; i<16; i++){ | |
2019 const int j= scantable[i]; | |
2020 int level= block[j]*quant_table[j]; | |
2021 | |
2022 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
2023 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
2024 if(((unsigned)(level+threshold1))>threshold2){ | |
2025 if(level>0){ | |
2026 level= (bias + level)>>QUANT_SHIFT; | |
2027 block[j]= level; | |
2028 }else{ | |
2029 level= (bias - level)>>QUANT_SHIFT; | |
2030 block[j]= -level; | |
2031 } | |
2032 last_non_zero = i; | |
2033 }else{ | |
2034 block[j]=0; | |
2035 } | |
2036 } | |
2037 | |
2038 return last_non_zero; | |
2039 } | |
2040 | |
2041 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
2042 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2043 ((uint32_t*)(src+0*stride))[0]= a; | |
2044 ((uint32_t*)(src+1*stride))[0]= a; | |
2045 ((uint32_t*)(src+2*stride))[0]= a; | |
2046 ((uint32_t*)(src+3*stride))[0]= a; | |
2047 } | |
2048 | |
2049 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
2050 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
2051 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
2052 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
2053 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
2054 } | |
2055 | |
2056 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2057 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
2058 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 2059 |
2060 ((uint32_t*)(src+0*stride))[0]= | |
2061 ((uint32_t*)(src+1*stride))[0]= | |
2062 ((uint32_t*)(src+2*stride))[0]= | |
2063 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2064 } |
2065 | |
2066 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2067 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 2068 |
2069 ((uint32_t*)(src+0*stride))[0]= | |
2070 ((uint32_t*)(src+1*stride))[0]= | |
2071 ((uint32_t*)(src+2*stride))[0]= | |
2072 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2073 } |
2074 | |
2075 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2076 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 2077 |
2078 ((uint32_t*)(src+0*stride))[0]= | |
2079 ((uint32_t*)(src+1*stride))[0]= | |
2080 ((uint32_t*)(src+2*stride))[0]= | |
2081 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2082 } |
2083 | |
2084 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2085 ((uint32_t*)(src+0*stride))[0]= |
2086 ((uint32_t*)(src+1*stride))[0]= | |
2087 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 2088 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
2089 } | |
2090 | |
2091 | |
2092 #define LOAD_TOP_RIGHT_EDGE\ | |
2093 const int t4= topright[0];\ | |
2094 const int t5= topright[1];\ | |
2095 const int t6= topright[2];\ | |
2096 const int t7= topright[3];\ | |
2097 | |
2098 #define LOAD_LEFT_EDGE\ | |
2099 const int l0= src[-1+0*stride];\ | |
2100 const int l1= src[-1+1*stride];\ | |
2101 const int l2= src[-1+2*stride];\ | |
2102 const int l3= src[-1+3*stride];\ | |
2103 | |
2104 #define LOAD_TOP_EDGE\ | |
2105 const int t0= src[ 0-1*stride];\ | |
2106 const int t1= src[ 1-1*stride];\ | |
2107 const int t2= src[ 2-1*stride];\ | |
2108 const int t3= src[ 3-1*stride];\ | |
2109 | |
2110 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2111 const int lt= src[-1-1*stride]; | |
2112 LOAD_TOP_EDGE | |
2113 LOAD_LEFT_EDGE | |
2114 | |
2967 | 2115 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 2116 src[0+2*stride]= |
2967 | 2117 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 2118 src[0+1*stride]= |
2119 src[1+2*stride]= | |
2967 | 2120 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 2121 src[0+0*stride]= |
2122 src[1+1*stride]= | |
2123 src[2+2*stride]= | |
2967 | 2124 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 2125 src[1+0*stride]= |
2126 src[2+1*stride]= | |
2127 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2128 src[2+0*stride]= | |
2129 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2130 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 2131 } |
1168 | 2132 |
2133 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2134 LOAD_TOP_EDGE |
2135 LOAD_TOP_RIGHT_EDGE | |
2136 // LOAD_LEFT_EDGE | |
1168 | 2137 |
2138 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
2139 src[1+0*stride]= | |
2140 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
2141 src[2+0*stride]= | |
2142 src[1+1*stride]= | |
2143 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
2144 src[3+0*stride]= | |
2145 src[2+1*stride]= | |
2146 src[1+2*stride]= | |
2147 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
2148 src[3+1*stride]= | |
2149 src[2+2*stride]= | |
2150 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
2151 src[3+2*stride]= | |
2152 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
2153 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 2154 } |
1168 | 2155 |
2156 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2157 const int lt= src[-1-1*stride]; | |
2967 | 2158 LOAD_TOP_EDGE |
2159 LOAD_LEFT_EDGE | |
1168 | 2160 const __attribute__((unused)) int unu= l3; |
2161 | |
2162 src[0+0*stride]= | |
2163 src[1+2*stride]=(lt + t0 + 1)>>1; | |
2164 src[1+0*stride]= | |
2165 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
2166 src[2+0*stride]= | |
2167 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
2168 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
2169 src[0+1*stride]= | |
2170 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2171 src[1+1*stride]= | |
2172 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2173 src[2+1*stride]= | |
2174 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2175 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2176 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2177 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 2178 } |
1168 | 2179 |
2180 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2181 LOAD_TOP_EDGE |
2182 LOAD_TOP_RIGHT_EDGE | |
1168 | 2183 const __attribute__((unused)) int unu= t7; |
2184 | |
2185 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
2186 src[1+0*stride]= | |
2187 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
2188 src[2+0*stride]= | |
2189 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
2190 src[3+0*stride]= | |
2191 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
2192 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
2193 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2194 src[1+1*stride]= | |
2195 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2196 src[2+1*stride]= | |
2197 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
2198 src[3+1*stride]= | |
2199 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
2200 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 2201 } |
1168 | 2202 |
2203 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2204 LOAD_LEFT_EDGE |
1168 | 2205 |
2206 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
2207 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2208 src[2+0*stride]= | |
2209 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
2210 src[3+0*stride]= | |
2211 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
2212 src[2+1*stride]= | |
2213 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
2214 src[3+1*stride]= | |
2215 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
2216 src[3+2*stride]= | |
2217 src[1+3*stride]= | |
2218 src[0+3*stride]= | |
2219 src[2+2*stride]= | |
2220 src[2+3*stride]= | |
2221 src[3+3*stride]=l3; | |
1282 | 2222 } |
2967 | 2223 |
1168 | 2224 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
2225 const int lt= src[-1-1*stride]; | |
2967 | 2226 LOAD_TOP_EDGE |
2227 LOAD_LEFT_EDGE | |
1168 | 2228 const __attribute__((unused)) int unu= t3; |
2229 | |
2230 src[0+0*stride]= | |
2231 src[2+1*stride]=(lt + l0 + 1)>>1; | |
2232 src[1+0*stride]= | |
2233 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2234 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2235 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2236 src[0+1*stride]= | |
2237 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
2238 src[1+1*stride]= | |
2239 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2240 src[0+2*stride]= | |
2241 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
2242 src[1+2*stride]= | |
2243 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2244 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
2245 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 2246 } |
1168 | 2247 |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2248 void ff_pred16x16_vertical_c(uint8_t *src, int stride){ |
1168 | 2249 int i; |
2250 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2251 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2252 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
2253 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 2254 |
1168 | 2255 for(i=0; i<16; i++){ |
2256 ((uint32_t*)(src+i*stride))[0]= a; | |
2257 ((uint32_t*)(src+i*stride))[1]= b; | |
2258 ((uint32_t*)(src+i*stride))[2]= c; | |
2259 ((uint32_t*)(src+i*stride))[3]= d; | |
2260 } | |
2261 } | |
2262 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2263 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){ |
1168 | 2264 int i; |
2265 | |
2266 for(i=0; i<16; i++){ | |
2267 ((uint32_t*)(src+i*stride))[0]= | |
2268 ((uint32_t*)(src+i*stride))[1]= | |
2269 ((uint32_t*)(src+i*stride))[2]= | |
2270 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
2271 } | |
2272 } | |
2273 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2274 void ff_pred16x16_dc_c(uint8_t *src, int stride){ |
1168 | 2275 int i, dc=0; |
2276 | |
2277 for(i=0;i<16; i++){ | |
2278 dc+= src[-1+i*stride]; | |
2279 } | |
2967 | 2280 |
1168 | 2281 for(i=0;i<16; i++){ |
2282 dc+= src[i-stride]; | |
2283 } | |
2284 | |
2285 dc= 0x01010101*((dc + 16)>>5); | |
2286 | |
2287 for(i=0; i<16; i++){ | |
2288 ((uint32_t*)(src+i*stride))[0]= | |
2289 ((uint32_t*)(src+i*stride))[1]= | |
2290 ((uint32_t*)(src+i*stride))[2]= | |
2291 ((uint32_t*)(src+i*stride))[3]= dc; | |
2292 } | |
2293 } | |
2294 | |
2295 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
2296 int i, dc=0; | |
2297 | |
2298 for(i=0;i<16; i++){ | |
2299 dc+= src[-1+i*stride]; | |
2300 } | |
2967 | 2301 |
1168 | 2302 dc= 0x01010101*((dc + 8)>>4); |
2303 | |
2304 for(i=0; i<16; i++){ | |
2305 ((uint32_t*)(src+i*stride))[0]= | |
2306 ((uint32_t*)(src+i*stride))[1]= | |
2307 ((uint32_t*)(src+i*stride))[2]= | |
2308 ((uint32_t*)(src+i*stride))[3]= dc; | |
2309 } | |
2310 } | |
2311 | |
2312 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
2313 int i, dc=0; | |
2314 | |
2315 for(i=0;i<16; i++){ | |
2316 dc+= src[i-stride]; | |
2317 } | |
2318 dc= 0x01010101*((dc + 8)>>4); | |
2319 | |
2320 for(i=0; i<16; i++){ | |
2321 ((uint32_t*)(src+i*stride))[0]= | |
2322 ((uint32_t*)(src+i*stride))[1]= | |
2323 ((uint32_t*)(src+i*stride))[2]= | |
2324 ((uint32_t*)(src+i*stride))[3]= dc; | |
2325 } | |
2326 } | |
2327 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2328 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){ |
1168 | 2329 int i; |
2330 | |
2331 for(i=0; i<16; i++){ | |
2332 ((uint32_t*)(src+i*stride))[0]= | |
2333 ((uint32_t*)(src+i*stride))[1]= | |
2334 ((uint32_t*)(src+i*stride))[2]= | |
2335 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
2336 } | |
2337 } | |
2338 | |
1234 | 2339 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
|
2340 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2341 int a; |
4176 | 2342 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
|
2343 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
|
2344 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
|
2345 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
|
2346 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
|
2347 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
|
2348 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
|
2349 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2350 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
|
2351 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
|
2352 } |
1234 | 2353 if(svq3){ |
2354 H = ( 5*(H/4) ) / 16; | |
2355 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2356 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2357 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2358 i = H; H = V; V = i; |
1234 | 2359 }else{ |
2360 H = ( 5*H+32 ) >> 6; | |
2361 V = ( 5*V+32 ) >> 6; | |
2362 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2363 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2364 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
|
2365 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
|
2366 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2367 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2368 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
|
2369 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
|
2370 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
|
2371 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
|
2372 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
|
2373 b += 4*H; |
1168 | 2374 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2375 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2376 } |
1168 | 2377 } |
2378 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2379 void ff_pred16x16_plane_c(uint8_t *src, int stride){ |
1234 | 2380 pred16x16_plane_compat_c(src, stride, 0); |
2381 } | |
2382 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2383 void ff_pred8x8_vertical_c(uint8_t *src, int stride){ |
1168 | 2384 int i; |
2385 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2386 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2387 |
1168 | 2388 for(i=0; i<8; i++){ |
2389 ((uint32_t*)(src+i*stride))[0]= a; | |
2390 ((uint32_t*)(src+i*stride))[1]= b; | |
2391 } | |
2392 } | |
2393 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2394 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){ |
1168 | 2395 int i; |
2396 | |
2397 for(i=0; i<8; i++){ | |
2398 ((uint32_t*)(src+i*stride))[0]= | |
2399 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2400 } | |
2401 } | |
2402 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2403 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){ |
1168 | 2404 int i; |
2405 | |
2755 | 2406 for(i=0; i<8; i++){ |
2967 | 2407 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2408 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2409 } | |
2410 } | |
2411 | |
2412 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2413 int i; | |
2414 int dc0, dc2; | |
2415 | |
2416 dc0=dc2=0; | |
2417 for(i=0;i<4; i++){ | |
2418 dc0+= src[-1+i*stride]; | |
2419 dc2+= src[-1+(i+4)*stride]; | |
2420 } | |
2421 dc0= 0x01010101*((dc0 + 2)>>2); | |
2422 dc2= 0x01010101*((dc2 + 2)>>2); | |
2423 | |
2424 for(i=0; i<4; i++){ | |
2425 ((uint32_t*)(src+i*stride))[0]= | |
2426 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2427 } | |
2428 for(i=4; i<8; i++){ | |
2429 ((uint32_t*)(src+i*stride))[0]= | |
2430 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2431 } | |
2432 } | |
2433 | |
2434 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2435 int i; | |
2436 int dc0, dc1; | |
2437 | |
2438 dc0=dc1=0; | |
2439 for(i=0;i<4; i++){ | |
2440 dc0+= src[i-stride]; | |
2441 dc1+= src[4+i-stride]; | |
2442 } | |
2443 dc0= 0x01010101*((dc0 + 2)>>2); | |
2444 dc1= 0x01010101*((dc1 + 2)>>2); | |
2445 | |
2446 for(i=0; i<4; i++){ | |
2447 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2448 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2449 } | |
2450 for(i=4; i<8; i++){ | |
2451 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2452 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2453 } | |
2454 } | |
2455 | |
2456 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2457 void ff_pred8x8_dc_c(uint8_t *src, int stride){ |
1168 | 2458 int i; |
2459 int dc0, dc1, dc2, dc3; | |
2460 | |
2461 dc0=dc1=dc2=0; | |
2462 for(i=0;i<4; i++){ | |
2463 dc0+= src[-1+i*stride] + src[i-stride]; | |
2464 dc1+= src[4+i-stride]; | |
2465 dc2+= src[-1+(i+4)*stride]; | |
2466 } | |
2467 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2468 dc0= 0x01010101*((dc0 + 4)>>3); | |
2469 dc1= 0x01010101*((dc1 + 2)>>2); | |
2470 dc2= 0x01010101*((dc2 + 2)>>2); | |
2471 | |
2472 for(i=0; i<4; i++){ | |
2473 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2474 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2475 } | |
2476 for(i=4; i<8; i++){ | |
2477 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2478 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2479 } | |
2480 } | |
2481 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2482 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
|
2483 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2484 int a; |
4176 | 2485 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
|
2486 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
|
2487 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
|
2488 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
|
2489 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
|
2490 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
|
2491 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
|
2492 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2493 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
|
2494 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
|
2495 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2496 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2497 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2498 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2499 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
|
2500 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
|
2501 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2502 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2503 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2504 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
|
2505 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
|
2506 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
|
2507 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
|
2508 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
|
2509 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
|
2510 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
|
2511 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2512 } |
1168 | 2513 } |
2514 | |
2755 | 2515 #define SRC(x,y) src[(x)+(y)*stride] |
2516 #define PL(y) \ | |
2517 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2518 #define PREDICT_8x8_LOAD_LEFT \ | |
2519 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2520 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2521 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2522 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2523 |
2524 #define PT(x) \ | |
2525 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2526 #define PREDICT_8x8_LOAD_TOP \ | |
2527 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2528 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2529 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2530 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2531 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2532 |
2533 #define PTR(x) \ | |
2534 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2535 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2536 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2537 if(has_topright) { \ | |
2538 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2539 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2540 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2541 | |
2542 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2543 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2544 |
2545 #define PREDICT_8x8_DC(v) \ | |
2546 int y; \ | |
2547 for( y = 0; y < 8; y++ ) { \ | |
2548 ((uint32_t*)src)[0] = \ | |
2549 ((uint32_t*)src)[1] = v; \ | |
2550 src += stride; \ | |
2551 } | |
2552 | |
2553 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2554 { | |
2555 PREDICT_8x8_DC(0x80808080); | |
2556 } | |
2557 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2558 { | |
2559 PREDICT_8x8_LOAD_LEFT; | |
2560 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2561 PREDICT_8x8_DC(dc); | |
2562 } | |
2563 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2564 { | |
2565 PREDICT_8x8_LOAD_TOP; | |
2566 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2567 PREDICT_8x8_DC(dc); | |
2568 } | |
2569 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2570 { | |
2571 PREDICT_8x8_LOAD_LEFT; | |
2572 PREDICT_8x8_LOAD_TOP; | |
2573 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2574 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2575 PREDICT_8x8_DC(dc); | |
2576 } | |
2577 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2578 { | |
2579 PREDICT_8x8_LOAD_LEFT; | |
2580 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2581 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2582 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2583 #undef ROW | |
2584 } | |
2585 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2586 { | |
2587 int y; | |
2588 PREDICT_8x8_LOAD_TOP; | |
2589 src[0] = t0; | |
2590 src[1] = t1; | |
2591 src[2] = t2; | |
2592 src[3] = t3; | |
2593 src[4] = t4; | |
2594 src[5] = t5; | |
2595 src[6] = t6; | |
2596 src[7] = t7; | |
2597 for( y = 1; y < 8; y++ ) | |
2598 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2599 } | |
2600 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2601 { | |
2602 PREDICT_8x8_LOAD_TOP; | |
2603 PREDICT_8x8_LOAD_TOPRIGHT; | |
2604 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2605 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2606 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2607 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2608 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2609 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2610 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; | |
2611 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; | |
2612 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; | |
2613 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2614 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2615 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2616 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2617 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2618 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2619 } | |
2620 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2621 { | |
2622 PREDICT_8x8_LOAD_TOP; | |
2623 PREDICT_8x8_LOAD_LEFT; | |
2624 PREDICT_8x8_LOAD_TOPLEFT; | |
2625 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2626 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2627 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2628 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2629 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2630 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2631 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; | |
2632 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; | |
2633 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; | |
2634 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2635 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2636 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2637 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2638 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2639 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2640 |
2755 | 2641 } |
2642 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2643 { | |
2644 PREDICT_8x8_LOAD_TOP; | |
2645 PREDICT_8x8_LOAD_LEFT; | |
2646 PREDICT_8x8_LOAD_TOPLEFT; | |
2647 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2648 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2649 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2650 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2651 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2652 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2653 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2654 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2655 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2656 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2657 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2658 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2659 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2660 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2661 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2662 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2663 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2664 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2665 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2666 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2667 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2668 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2669 } | |
2670 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2671 { | |
2672 PREDICT_8x8_LOAD_TOP; | |
2673 PREDICT_8x8_LOAD_LEFT; | |
2674 PREDICT_8x8_LOAD_TOPLEFT; | |
2675 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2676 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2677 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2678 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2679 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2680 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2681 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2682 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2683 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2684 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2685 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2686 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2687 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2688 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2689 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2690 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2691 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2692 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2693 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2694 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2695 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2696 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2697 } | |
2698 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2699 { | |
2700 PREDICT_8x8_LOAD_TOP; | |
2701 PREDICT_8x8_LOAD_TOPRIGHT; | |
2702 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2703 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2704 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2705 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2706 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2707 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2708 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2709 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2710 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2711 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2712 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2713 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2714 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2715 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2716 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2717 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2718 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2719 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2720 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2721 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2722 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2723 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2724 } | |
2725 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2726 { | |
2727 PREDICT_8x8_LOAD_LEFT; | |
2728 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2729 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2730 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2731 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2732 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2733 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2734 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2735 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2736 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2737 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2738 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2739 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2740 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2741 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2742 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2743 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2744 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2745 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2746 } | |
2747 #undef PREDICT_8x8_LOAD_LEFT | |
2748 #undef PREDICT_8x8_LOAD_TOP | |
2749 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2750 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2751 #undef PREDICT_8x8_DC | |
2752 #undef PTR | |
2753 #undef PT | |
2754 #undef PL | |
2755 #undef SRC | |
2756 | |
1168 | 2757 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2758 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2759 int src_x_offset, int src_y_offset, | |
2760 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2761 MpegEncContext * const s = &h->s; | |
2762 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2763 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2764 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2765 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2766 uint8_t * src_cb, * src_cr; | |
2767 int extra_width= h->emu_edge_width; | |
2768 int extra_height= h->emu_edge_height; | |
1168 | 2769 int emu=0; |
2770 const int full_mx= mx>>2; | |
2771 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2772 const int pic_width = 16*s->mb_width; |
3316 | 2773 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2774 |
3125 | 2775 if(!pic->data[0]) |
2776 return; | |
2967 | 2777 |
1168 | 2778 if(mx&7) extra_width -= 3; |
2779 if(my&7) extra_height -= 3; | |
2967 | 2780 |
2781 if( full_mx < 0-extra_width | |
2782 || full_my < 0-extra_height | |
2783 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2784 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2785 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); |
2786 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2787 emu=1; |
2788 } | |
2967 | 2789 |
3316 | 2790 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2791 if(!square){ |
3316 | 2792 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2793 } |
2967 | 2794 |
1168 | 2795 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2796 |
3316 | 2797 if(MB_MBAFF){ |
2798 // chroma offset when predicting from a field of opposite parity | |
2799 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2800 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2801 } | |
2802 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2803 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2804 |
2805 if(emu){ | |
3316 | 2806 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); |
2807 src_cb= s->edge_emu_buffer; | |
2808 } | |
2809 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2810 | |
2811 if(emu){ | |
2812 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 | 2813 src_cr= s->edge_emu_buffer; |
2814 } | |
3316 | 2815 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2816 } |
2817 | |
2415 | 2818 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2819 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2820 int x_offset, int y_offset, | |
2821 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2822 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2823 int list0, int list1){ | |
2824 MpegEncContext * const s = &h->s; | |
2825 qpel_mc_func *qpix_op= qpix_put; | |
2826 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2827 |
3316 | 2828 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2829 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2830 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2831 x_offset += 8*s->mb_x; |
3316 | 2832 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2833 |
1168 | 2834 if(list0){ |
1169 | 2835 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2836 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2837 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2838 qpix_op, chroma_op); | |
2839 | |
2840 qpix_op= qpix_avg; | |
2841 chroma_op= chroma_avg; | |
2842 } | |
2843 | |
2844 if(list1){ | |
1169 | 2845 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2846 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2847 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2848 qpix_op, chroma_op); | |
2849 } | |
2850 } | |
2851 | |
2415 | 2852 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2853 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2854 int x_offset, int y_offset, | |
2855 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2856 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2857 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2858 int list0, int list1){ | |
2859 MpegEncContext * const s = &h->s; | |
2860 | |
3316 | 2861 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2862 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2863 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2864 x_offset += 8*s->mb_x; |
3316 | 2865 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2866 |
2415 | 2867 if(list0 && list1){ |
2868 /* don't optimize for luma-only case, since B-frames usually | |
2869 * use implicit weights => chroma too. */ | |
2870 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2871 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2872 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2873 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2874 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2875 | |
2876 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2877 dest_y, dest_cb, dest_cr, | |
2878 x_offset, y_offset, qpix_put, chroma_put); | |
2879 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2880 tmp_y, tmp_cb, tmp_cr, | |
2881 x_offset, y_offset, qpix_put, chroma_put); | |
2882 | |
2883 if(h->use_weight == 2){ | |
2884 int weight0 = h->implicit_weight[refn0][refn1]; | |
2885 int weight1 = 64 - weight0; | |
3316 | 2886 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2887 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2888 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 2889 }else{ |
3316 | 2890 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 2891 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 2892 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 2893 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2894 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 2895 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 2896 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2897 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 2898 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 2899 } |
2900 }else{ | |
2901 int list = list1 ? 1 : 0; | |
2902 int refn = h->ref_cache[list][ scan8[n] ]; | |
2903 Picture *ref= &h->ref_list[list][refn]; | |
2904 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2905 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2906 qpix_put, chroma_put); | |
2907 | |
3316 | 2908 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 2909 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
2910 if(h->use_weight_chroma){ | |
3316 | 2911 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2912 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 2913 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2914 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
2915 } | |
2916 } | |
2917 } | |
2918 | |
2919 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2920 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2921 int x_offset, int y_offset, | |
2922 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2923 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 2924 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 2925 int list0, int list1){ |
2926 if((h->use_weight==2 && list0 && list1 | |
2927 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2928 || h->use_weight==1) | |
2929 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2930 x_offset, y_offset, qpix_put, chroma_put, | |
2931 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2932 else | |
2933 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2934 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2935 } | |
2936 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2937 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
|
2938 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2939 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2940 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2941 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
|
2942 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2943 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
|
2944 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
|
2945 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 2946 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
|
2947 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
|
2948 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
|
2949 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
|
2950 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2951 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2952 |
1168 | 2953 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2954 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2955 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2956 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2957 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
|
2958 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2959 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 2960 |
1168 | 2961 assert(IS_INTER(mb_type)); |
2967 | 2962 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2963 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2964 |
1168 | 2965 if(IS_16X16(mb_type)){ |
2966 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2967 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2968 &weight_op[0], &weight_avg[0], |
1168 | 2969 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2970 }else if(IS_16X8(mb_type)){ | |
2971 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2972 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2973 &weight_op[1], &weight_avg[1], |
1168 | 2974 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2975 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
2976 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2977 &weight_op[1], &weight_avg[1], |
1168 | 2978 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2979 }else if(IS_8X16(mb_type)){ | |
3316 | 2980 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 2981 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2982 &weight_op[2], &weight_avg[2], |
1168 | 2983 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 2984 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 2985 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2986 &weight_op[2], &weight_avg[2], |
1168 | 2987 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2988 }else{ | |
2989 int i; | |
2967 | 2990 |
1168 | 2991 assert(IS_8X8(mb_type)); |
2992 | |
2993 for(i=0; i<4; i++){ | |
2994 const int sub_mb_type= h->sub_mb_type[i]; | |
2995 const int n= 4*i; | |
2996 int x_offset= (i&1)<<2; | |
2997 int y_offset= (i&2)<<1; | |
2998 | |
2999 if(IS_SUB_8X8(sub_mb_type)){ | |
3000 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3001 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 3002 &weight_op[3], &weight_avg[3], |
1168 | 3003 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3004 }else if(IS_SUB_8X4(sub_mb_type)){ | |
3005 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3006 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3007 &weight_op[4], &weight_avg[4], |
1168 | 3008 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3009 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
3010 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3011 &weight_op[4], &weight_avg[4], |
1168 | 3012 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3013 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 3014 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 3015 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3016 &weight_op[5], &weight_avg[5], |
1168 | 3017 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 3018 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 3019 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3020 &weight_op[5], &weight_avg[5], |
1168 | 3021 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3022 }else{ | |
3023 int j; | |
3024 assert(IS_SUB_4X4(sub_mb_type)); | |
3025 for(j=0; j<4; j++){ | |
3026 int sub_x_offset= x_offset + 2*(j&1); | |
3027 int sub_y_offset= y_offset + (j&2); | |
3028 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
3029 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 3030 &weight_op[6], &weight_avg[6], |
1168 | 3031 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3032 } | |
3033 } | |
3034 } | |
3035 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3036 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3037 prefetch_motion(h, 1); |
1168 | 3038 } |
3039 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3040 static void decode_init_vlc(){ |
1168 | 3041 static int done = 0; |
3042 | |
3043 if (!done) { | |
3044 int i; | |
3045 done = 1; | |
3046 | |
2967 | 3047 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 3048 &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
|
3049 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 3050 |
3051 for(i=0; i<4; i++){ | |
2967 | 3052 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 3053 &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
|
3054 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 3055 } |
3056 | |
3057 for(i=0; i<3; i++){ | |
3058 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
3059 &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
|
3060 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3061 } |
3062 for(i=0; i<15; i++){ | |
2967 | 3063 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 3064 &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
|
3065 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3066 } |
3067 | |
3068 for(i=0; i<6; i++){ | |
2967 | 3069 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 3070 &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
|
3071 &run_bits[i][0], 1, 1, 1); |
1168 | 3072 } |
2967 | 3073 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 3074 &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
|
3075 &run_bits[6][0], 1, 1, 1); |
1168 | 3076 } |
3077 } | |
3078 | |
3079 /** | |
3080 * Sets the intra prediction function pointers. | |
3081 */ | |
3082 static void init_pred_ptrs(H264Context *h){ | |
3083 // MpegEncContext * const s = &h->s; | |
3084 | |
3085 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
3086 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
3087 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
3088 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
3089 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
3090 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
3091 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
3092 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
3093 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
3094 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
3095 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
3096 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
3097 | |
2755 | 3098 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
3099 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
3100 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
3101 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
3102 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
3103 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
3104 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
3105 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
3106 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
3107 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
3108 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
3109 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
3110 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3111 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3112 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3113 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3114 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c; |
1168 | 3115 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; |
3116 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
|
3117 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
|
3118 |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3119 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3120 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3121 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3122 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c; |
1168 | 3123 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; |
3124 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
|
3125 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c; |
1168 | 3126 } |
3127 | |
3128 static void free_tables(H264Context *h){ | |
3129 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
|
3130 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
|
3131 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
|
3132 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
|
3133 av_freep(&h->mvd_table[1]); |
2396 | 3134 av_freep(&h->direct_table); |
1168 | 3135 av_freep(&h->non_zero_count); |
3136 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
|
3137 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3138 av_freep(&h->top_borders[0]); |
1168 | 3139 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
|
3140 |
1168 | 3141 av_freep(&h->mb2b_xy); |
3142 av_freep(&h->mb2b8_xy); | |
2415 | 3143 |
3144 av_freep(&h->s.obmc_scratchpad); | |
1168 | 3145 } |
3146 | |
2919 | 3147 static void init_dequant8_coeff_table(H264Context *h){ |
3148 int i,q,x; | |
3174 | 3149 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 3150 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
3151 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
3152 | |
3153 for(i=0; i<2; i++ ){ | |
3154 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
3155 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
3156 break; | |
3157 } | |
3158 | |
3159 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3160 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3161 int idx = ff_rem6[q]; |
2919 | 3162 for(x=0; x<64; x++) |
3174 | 3163 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
3164 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
3165 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 3166 } |
3167 } | |
3168 } | |
3169 | |
3170 static void init_dequant4_coeff_table(H264Context *h){ | |
3171 int i,j,q,x; | |
3005 | 3172 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 3173 for(i=0; i<6; i++ ){ |
3174 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
3175 for(j=0; j<i; j++){ | |
3176 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
3177 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
3178 break; | |
3179 } | |
3180 } | |
3181 if(j<i) | |
3182 continue; | |
3183 | |
3184 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3185 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3186 int idx = ff_rem6[q]; |
2919 | 3187 for(x=0; x<16; x++) |
3005 | 3188 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
3189 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 3190 h->pps.scaling_matrix4[i][x]) << shift; |
3191 } | |
3192 } | |
3193 } | |
3194 | |
3195 static void init_dequant_tables(H264Context *h){ | |
3196 int i,x; | |
3197 init_dequant4_coeff_table(h); | |
3198 if(h->pps.transform_8x8_mode) | |
3199 init_dequant8_coeff_table(h); | |
3200 if(h->sps.transform_bypass){ | |
3201 for(i=0; i<6; i++) | |
3202 for(x=0; x<16; x++) | |
3203 h->dequant4_coeff[i][0][x] = 1<<6; | |
3204 if(h->pps.transform_8x8_mode) | |
3205 for(i=0; i<2; i++) | |
3206 for(x=0; x<64; x++) | |
3207 h->dequant8_coeff[i][0][x] = 1<<6; | |
3208 } | |
3209 } | |
3210 | |
3211 | |
1168 | 3212 /** |
3213 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3214 * needs width/height |
1168 | 3215 */ |
3216 static int alloc_tables(H264Context *h){ | |
3217 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
|
3218 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 3219 int x,y; |
1168 | 3220 |
3221 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
|
3222 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3223 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 3224 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
|
3225 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
|
3226 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 3227 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 3228 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3229 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
|
3230 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
|
3231 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
|
3232 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 3233 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
|
3234 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3235 |
3316 | 3236 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
3237 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 3238 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
3239 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
|
3240 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 3241 for(y=0; y<s->mb_height; y++){ |
3242 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
|
3243 const int mb_xy= x + y*s->mb_stride; |
1168 | 3244 const int b_xy = 4*x + 4*y*h->b_stride; |
3245 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 3246 |
1168 | 3247 h->mb2b_xy [mb_xy]= b_xy; |
3248 h->mb2b8_xy[mb_xy]= b8_xy; | |
3249 } | |
3250 } | |
2415 | 3251 |
2417 | 3252 s->obmc_scratchpad = NULL; |
3253 | |
2920 | 3254 if(!h->dequant4_coeff[0]) |
3255 init_dequant_tables(h); | |
3256 | |
1168 | 3257 return 0; |
3258 fail: | |
3259 free_tables(h); | |
3260 return -1; | |
3261 } | |
3262 | |
3263 static void common_init(H264Context *h){ | |
3264 MpegEncContext * const s = &h->s; | |
3265 | |
3266 s->width = s->avctx->width; | |
3267 s->height = s->avctx->height; | |
3268 s->codec_id= s->avctx->codec->id; | |
2967 | 3269 |
1168 | 3270 init_pred_ptrs(h); |
3271 | |
2919 | 3272 h->dequant_coeff_pps= -1; |
1698 | 3273 s->unrestricted_mv=1; |
1168 | 3274 s->decode=1; //FIXME |
2920 | 3275 |
3276 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
3277 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 3278 } |
3279 | |
3280 static int decode_init(AVCodecContext *avctx){ | |
3281 H264Context *h= avctx->priv_data; | |
3282 MpegEncContext * const s = &h->s; | |
3283 | |
1892 | 3284 MPV_decode_defaults(s); |
2967 | 3285 |
1168 | 3286 s->avctx = avctx; |
3287 common_init(h); | |
3288 | |
3289 s->out_format = FMT_H264; | |
3290 s->workaround_bugs= avctx->workaround_bugs; | |
3291 | |
3292 // set defaults | |
3293 // s->decode_mb= ff_h263_decode_mb; | |
3294 s->low_delay= 1; | |
3295 avctx->pix_fmt= PIX_FMT_YUV420P; | |
3296 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3297 decode_init_vlc(); |
2967 | 3298 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3299 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
|
3300 *(char *)avctx->extradata == 1){ |
2227 | 3301 h->is_avc = 1; |
3302 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
|
3303 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3304 h->is_avc = 0; |
2227 | 3305 } |
3306 | |
1168 | 3307 return 0; |
3308 } | |
3309 | |
2935 | 3310 static int frame_start(H264Context *h){ |
1168 | 3311 MpegEncContext * const s = &h->s; |
3312 int i; | |
3313 | |
2935 | 3314 if(MPV_frame_start(s, s->avctx) < 0) |
3315 return -1; | |
1168 | 3316 ff_er_frame_start(s); |
3317 | |
3318 assert(s->linesize && s->uvlinesize); | |
3319 | |
3320 for(i=0; i<16; i++){ | |
3321 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
|
3322 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 3323 } |
3324 for(i=0; i<4; i++){ | |
3325 h->block_offset[16+i]= | |
3326 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
|
3327 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3328 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 3329 } |
3330 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
3331 /* 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
|
3332 * 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
|
3333 if(!s->obmc_scratchpad) |
3316 | 3334 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
3335 | |
3336 /* some macroblocks will be accessed before they're available */ | |
3337 if(FRAME_MBAFF) | |
3338 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
|
3339 |
1168 | 3340 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 3341 return 0; |
1168 | 3342 } |
3343 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3344 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
|
3345 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
|
3346 int i; |
2967 | 3347 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3348 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
|
3349 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
|
3350 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
|
3351 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3352 // 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
|
3353 // 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
|
3354 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
|
3355 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
|
3356 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
|
3357 } |
2967 | 3358 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3359 *(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
|
3360 *(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
|
3361 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3362 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
|
3363 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
|
3364 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
|
3365 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
|
3366 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
|
3367 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
|
3368 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3369 *(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
|
3370 *(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
|
3371 } |
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 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3374 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
|
3375 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
|
3376 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
|
3377 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3378 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
|
3379 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
|
3380 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3381 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
|
3382 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
|
3383 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
|
3384 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3385 #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
|
3386 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3387 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3388 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3389 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3390 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3391 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3392 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
|
3393 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
|
3394 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3395 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3396 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3397 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3398 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
|
3399 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3400 if(s->mb_x+1 < s->mb_width){ |
2755 | 3401 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3402 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3403 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3404 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3405 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
|
3406 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3407 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
|
3408 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
|
3409 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
|
3410 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3411 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3412 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3413 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
|
3414 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
|
3415 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3416 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3417 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3418 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3419 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
|
3420 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3421 int i; |
2967 | 3422 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3423 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3424 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3425 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3426 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3427 // 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
|
3428 // 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
|
3429 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
|
3430 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
|
3431 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3432 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
|
3433 } |
2967 | 3434 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3435 *(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
|
3436 *(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
|
3437 *(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
|
3438 *(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
|
3439 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3440 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3441 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
|
3442 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
|
3443 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
|
3444 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
|
3445 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3446 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
|
3447 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
|
3448 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3449 *(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
|
3450 *(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
|
3451 *(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
|
3452 *(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
|
3453 } |
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 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3456 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
|
3457 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3458 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3459 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3460 int deblock_left = (s->mb_x > 0); |
3316 | 3461 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
|
3462 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3463 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
|
3464 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3465 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3466 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3467 src_cr -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3468 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3469 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3470 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3471 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3472 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3473 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3474 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3475 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3476 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
|
3477 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
|
3478 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3479 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3480 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3481 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3482 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
|
3483 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
|
3484 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
|
3485 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3486 if(s->mb_x+1 < s->mb_width){ |
3487 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3488 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3489 } | |
2581
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 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3492 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3493 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3494 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
|
3495 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
|
3496 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
|
3497 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3498 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3499 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3500 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
|
3501 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
|
3502 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
|
3503 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
|
3504 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3505 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3506 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3507 |
1168 | 3508 static void hl_decode_mb(H264Context *h){ |
3509 MpegEncContext * const s = &h->s; | |
3510 const int mb_x= s->mb_x; | |
3511 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
|
3512 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3513 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3514 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3515 int linesize, uvlinesize /*dct_offset*/; | |
3516 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3517 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
|
3518 const unsigned int bottom = mb_y & 1; |
2763 | 3519 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass); |
3520 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
|
3521 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3522 |
3523 if(!s->decode) | |
3524 return; | |
3525 | |
3526 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3527 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3528 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3529 | |
4000 | 3530 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3531 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3532 | |
3316 | 3533 if (MB_FIELD) { |
3534 linesize = h->mb_linesize = s->linesize * 2; | |
3535 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
|
3536 block_offset = &h->block_offset[24]; |
1168 | 3537 if(mb_y&1){ //FIXME move out of this func? |
3538 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3539 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3540 dest_cr-= s->uvlinesize*7; |
1168 | 3541 } |
3316 | 3542 if(FRAME_MBAFF) { |
3543 int list; | |
3544 for(list=0; list<2; list++){ | |
3545 if(!USES_LIST(mb_type, list)) | |
3546 continue; | |
3547 if(IS_16X16(mb_type)){ | |
3548 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3549 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3550 }else{ | |
3551 for(i=0; i<16; i+=4){ | |
3552 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3553 int ref = h->ref_cache[list][scan8[i]]; | |
3554 if(ref >= 0) | |
3555 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3556 } | |
3557 } | |
3558 } | |
3559 } | |
1168 | 3560 } else { |
3316 | 3561 linesize = h->mb_linesize = s->linesize; |
3562 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3563 // dct_offset = s->linesize * 16; |
3564 } | |
2967 | 3565 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3566 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3567 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3568 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
|
3569 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3570 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3571 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3572 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3573 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3574 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3575 } |
1168 | 3576 |
3316 | 3577 if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3578 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ | |
3579 int mbt_y = mb_y&~1; | |
3580 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3581 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3582 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3583 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3584 } | |
3585 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3586 if (IS_INTRA_PCM(mb_type)) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3587 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3588 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3589 // 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
|
3590 // 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
|
3591 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3592 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3593 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
|
3594 *(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
|
3595 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3596 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3597 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3598 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3599 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3600 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
|
3601 *(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
|
3602 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3603 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3604 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3605 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3606 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3607 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
|
3608 *(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
|
3609 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3610 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3611 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3612 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3613 if(IS_INTRA(mb_type)){ |
3316 | 3614 if(h->deblocking_filter && !FRAME_MBAFF) |
3615 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
|
3616 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3617 if(!(s->flags&CODEC_FLAG_GRAY)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3618 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
|
3619 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
|
3620 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3621 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3622 if(IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3623 if(!s->encoding){ |
2755 | 3624 if(IS_8x8DCT(mb_type)){ |
3625 for(i=0; i<16; i+=4){ | |
3626 uint8_t * const ptr= dest_y + block_offset[i]; | |
3627 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
|
3628 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3629 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
3630 (h->topright_samples_available<<(i+1))&0x8000, linesize); | |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3631 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3632 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3633 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3634 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3635 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3636 } |
2755 | 3637 } |
3638 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3639 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
|
3640 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
|
3641 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3642 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
|
3643 int nnz, tr; |
2509
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 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
|
3646 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
|
3647 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
|
3648 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3649 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3650 topright= (uint8_t*) &tr; |
2967 | 3651 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3652 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3653 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3654 topright= NULL; |
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 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3657 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3658 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3659 if(s->codec_id == CODEC_ID_H264){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3660 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3661 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3662 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3663 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3664 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3665 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
|
3666 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3667 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3668 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3669 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3670 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
2763 | 3671 if(s->codec_id == CODEC_ID_H264){ |
3672 if(!transform_bypass) | |
2919 | 3673 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3674 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3675 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
|
3676 } |
3316 | 3677 if(h->deblocking_filter && !FRAME_MBAFF) |
3678 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3679 }else if(s->codec_id == CODEC_ID_H264){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3680 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
|
3681 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
|
3682 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
|
3683 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
|
3684 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3685 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3686 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3687 if(!IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3688 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3689 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3690 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3691 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3692 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
|
3693 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3694 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
|
3695 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3696 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3697 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3698 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3699 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3700 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3701 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3702 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
|
3703 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3704 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
|
3705 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3706 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3707 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3708 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3709 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
|
3710 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
|
3711 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
|
3712 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3713 } |
1168 | 3714 } |
3715 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3716 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3717 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3718 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3719 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3720 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3721 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3722 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3723 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3724 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3725 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]); |
3726 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 | 3727 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3728 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3729 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3730 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3731 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
|
3732 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3733 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
|
3734 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3735 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3736 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
|
3737 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
|
3738 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
|
3739 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
|
3740 } |
1250 | 3741 } |
1168 | 3742 } |
3743 } | |
3744 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3745 if(h->deblocking_filter) { |
3316 | 3746 if (FRAME_MBAFF) { |
3747 //FIXME try deblocking one mb at a time? | |
3748 // 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
|
3749 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
|
3750 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
|
3751 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
|
3752 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
|
3753 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
|
3754 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3755 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
|
3756 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
|
3757 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
|
3758 |
3316 | 3759 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3760 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3761 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3762 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3763 // deblock a pair |
2967 | 3764 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3765 s->mb_y--; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3766 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
|
3767 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3768 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
|
3769 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
|
3770 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3771 s->mb_y++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3772 tprintf("call mbaff filter_mb\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3773 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3774 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
|
3775 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
|
3776 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3777 tprintf("call filter_mb\n"); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3778 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
|
3779 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
|
3780 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
|
3781 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3782 } |
1168 | 3783 } |
3784 | |
3785 /** | |
3786 * fills the default_ref_list. | |
3787 */ | |
3788 static int fill_default_ref_list(H264Context *h){ | |
3789 MpegEncContext * const s = &h->s; | |
3790 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
|
3791 int smallest_poc_greater_than_current = -1; |
2582 | 3792 Picture sorted_short_ref[32]; |
2967 | 3793 |
1168 | 3794 if(h->slice_type==B_TYPE){ |
3795 int out_i; | |
2713 | 3796 int limit= INT_MIN; |
1168 | 3797 |
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
|
3798 /* sort frame according to poc in B slice */ |
1168 | 3799 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3800 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
|
3801 int best_poc=INT_MAX; |
1168 | 3802 |
3803 for(i=0; i<h->short_ref_count; i++){ | |
3804 const int poc= h->short_ref[i]->poc; | |
3805 if(poc > limit && poc < best_poc){ | |
3806 best_poc= poc; | |
3807 best_i= i; | |
3808 } | |
3809 } | |
2967 | 3810 |
2713 | 3811 assert(best_i != INT_MIN); |
2967 | 3812 |
1168 | 3813 limit= best_poc; |
3814 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
|
3815 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
|
3816 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
|
3817 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
|
3818 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
|
3819 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3820 } |
1168 | 3821 } |
3822 } | |
3823 | |
3824 if(s->picture_structure == PICT_FRAME){ | |
3825 if(h->slice_type==B_TYPE){ | |
3826 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
|
3827 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
|
3828 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3829 // find the largest poc |
1168 | 3830 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
|
3831 int index = 0; |
2447 | 3832 int j= -99; |
3833 int step= list ? -1 : 1; | |
3834 | |
3835 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3836 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
|
3837 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3838 return -1; |
2447 | 3839 step = -step; |
3840 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
|
3841 } |
2447 | 3842 if(sorted_short_ref[j].reference != 3) continue; |
3843 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3844 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3845 } |
3846 | |
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
|
3847 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
|
3848 if(h->long_ref[i] == NULL) continue; |
1168 | 3849 if(h->long_ref[i]->reference != 3) continue; |
3850 | |
3851 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3852 h->default_ref_list[ list ][index++].pic_id= i;; | |
3853 } | |
2967 | 3854 |
2447 | 3855 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
|
3856 // 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
|
3857 // L0 and L1 are identical |
1168 | 3858 Picture temp= h->default_ref_list[1][0]; |
3859 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3860 h->default_ref_list[1][1] = temp; |
1168 | 3861 } |
3862 | |
3863 if(index < h->ref_count[ list ]) | |
3864 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3865 } | |
3866 }else{ | |
3867 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3868 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3869 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3870 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3871 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3872 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3873 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
|
3874 if(h->long_ref[i] == NULL) continue; |
1168 | 3875 if(h->long_ref[i]->reference != 3) continue; |
3876 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3877 h->default_ref_list[0][index++].pic_id= i;; | |
3878 } | |
3879 if(index < h->ref_count[0]) | |
3880 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3881 } | |
3882 }else{ //FIELD | |
3883 if(h->slice_type==B_TYPE){ | |
3884 }else{ | |
3885 //FIXME second field balh | |
3886 } | |
3887 } | |
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
|
3888 #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
|
3889 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
|
3890 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
|
3891 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3892 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
|
3893 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
|
3894 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
|
3895 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3896 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3897 #endif |
1168 | 3898 return 0; |
3899 } | |
3900 | |
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
|
3901 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
|
3902 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
|
3903 |
1168 | 3904 static int decode_ref_pic_list_reordering(H264Context *h){ |
3905 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3906 int list, index; |
2967 | 3907 |
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
|
3908 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
|
3909 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3910 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 3911 |
1168 | 3912 for(list=0; list<2; list++){ |
3913 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); | |
3914 | |
3915 if(get_bits1(&s->gb)){ | |
3916 int pred= h->curr_pic_num; | |
3917 | |
3918 for(index=0; ; index++){ | |
3919 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); | |
3920 int pic_id; | |
3921 int i; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3922 Picture *ref = NULL; |
2967 | 3923 |
3924 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
|
3925 break; |
2967 | 3926 |
1168 | 3927 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3928 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3929 return -1; |
3930 } | |
2967 | 3931 |
1168 | 3932 if(reordering_of_pic_nums_idc<3){ |
3933 if(reordering_of_pic_nums_idc<2){ | |
3934 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; | |
3935 | |
3936 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
|
3937 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3938 return -1; |
3939 } | |
3940 | |
3941 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3942 else pred+= abs_diff_pic_num; | |
3943 pred &= h->max_pic_num - 1; | |
2967 | 3944 |
2683 | 3945 for(i= h->short_ref_count-1; i>=0; i--){ |
3946 ref = h->short_ref[i]; | |
3947 assert(ref->reference == 3); | |
3948 assert(!ref->long_ref); | |
3949 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 3950 break; |
3951 } | |
2683 | 3952 if(i>=0) |
3953 ref->pic_id= ref->frame_num; | |
1168 | 3954 }else{ |
3955 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
2683 | 3956 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
|
3957 if(ref){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3958 ref->pic_id= pic_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3959 assert(ref->reference == 3); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3960 assert(ref->long_ref); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3961 i=0; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3962 }else{ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3963 i=-1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3964 } |
1168 | 3965 } |
3966 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3967 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3968 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3969 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 3970 } else { |
3971 for(i=index; i+1<h->ref_count[list]; i++){ | |
3972 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
3973 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
|
3974 } |
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
|
3975 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
|
3976 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
|
3977 } |
2683 | 3978 h->ref_list[list][index]= *ref; |
1168 | 3979 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3980 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3981 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3982 return -1; |
3983 } | |
3984 } | |
3985 } | |
3986 | |
3987 if(h->slice_type!=B_TYPE) break; | |
3988 } | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3989 for(list=0; list<2; list++){ |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3990 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
|
3991 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3992 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3993 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3994 if(h->slice_type!=B_TYPE) break; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3995 } |
2967 | 3996 |
2396 | 3997 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
3998 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3999 direct_ref_list_init(h); |
2967 | 4000 return 0; |
1168 | 4001 } |
4002 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
4003 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 4004 int list, i, j; |
4005 for(list=0; list<2; list++){ | |
4006 for(i=0; i<h->ref_count[list]; i++){ | |
4007 Picture *frame = &h->ref_list[list][i]; | |
4008 Picture *field = &h->ref_list[list][16+2*i]; | |
4009 field[0] = *frame; | |
4010 for(j=0; j<3; j++) | |
4011 field[0].linesize[j] <<= 1; | |
4012 field[1] = field[0]; | |
4013 for(j=0; j<3; j++) | |
4014 field[1].data[j] += frame->linesize[j]; | |
4015 | |
4016 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4017 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4018 for(j=0; j<2; j++){ | |
4019 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4020 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4021 } | |
4022 } | |
4023 } | |
4024 for(j=0; j<h->ref_count[1]; j++){ | |
4025 for(i=0; i<h->ref_count[0]; i++) | |
4026 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4027 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4028 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4029 } | |
4030 } | |
4031 | |
1168 | 4032 static int pred_weight_table(H264Context *h){ |
4033 MpegEncContext * const s = &h->s; | |
4034 int list, i; | |
2415 | 4035 int luma_def, chroma_def; |
2967 | 4036 |
2415 | 4037 h->use_weight= 0; |
4038 h->use_weight_chroma= 0; | |
1168 | 4039 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4040 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4041 luma_def = 1<<h->luma_log2_weight_denom; |
4042 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4043 |
4044 for(list=0; list<2; list++){ | |
4045 for(i=0; i<h->ref_count[list]; i++){ | |
4046 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4047 |
1168 | 4048 luma_weight_flag= get_bits1(&s->gb); |
4049 if(luma_weight_flag){ | |
4050 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4051 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4052 if( h->luma_weight[list][i] != luma_def |
4053 || h->luma_offset[list][i] != 0) | |
4054 h->use_weight= 1; | |
4055 }else{ | |
4056 h->luma_weight[list][i]= luma_def; | |
4057 h->luma_offset[list][i]= 0; | |
1168 | 4058 } |
4059 | |
4060 chroma_weight_flag= get_bits1(&s->gb); | |
4061 if(chroma_weight_flag){ | |
4062 int j; | |
4063 for(j=0; j<2; j++){ | |
4064 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4065 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4066 if( h->chroma_weight[list][i][j] != chroma_def |
4067 || h->chroma_offset[list][i][j] != 0) | |
4068 h->use_weight_chroma= 1; | |
4069 } | |
4070 }else{ | |
4071 int j; | |
4072 for(j=0; j<2; j++){ | |
4073 h->chroma_weight[list][i][j]= chroma_def; | |
4074 h->chroma_offset[list][i][j]= 0; | |
1168 | 4075 } |
4076 } | |
4077 } | |
4078 if(h->slice_type != B_TYPE) break; | |
4079 } | |
2415 | 4080 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4081 return 0; |
4082 } | |
4083 | |
2415 | 4084 static void implicit_weight_table(H264Context *h){ |
4085 MpegEncContext * const s = &h->s; | |
4086 int ref0, ref1; | |
4087 int cur_poc = s->current_picture_ptr->poc; | |
4088 | |
4089 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4090 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4091 h->use_weight= 0; | |
4092 h->use_weight_chroma= 0; | |
4093 return; | |
4094 } | |
4095 | |
4096 h->use_weight= 2; | |
4097 h->use_weight_chroma= 2; | |
4098 h->luma_log2_weight_denom= 5; | |
4099 h->chroma_log2_weight_denom= 5; | |
4100 | |
4101 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4102 int poc0 = h->ref_list[0][ref0].poc; | |
4103 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4104 int poc1 = h->ref_list[1][ref1].poc; |
2415 | 4105 int td = clip(poc1 - poc0, -128, 127); |
4106 if(td){ | |
4107 int tb = clip(cur_poc - poc0, -128, 127); | |
4001 | 4108 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2415 | 4109 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
4110 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
4111 h->implicit_weight[ref0][ref1] = 32; | |
4112 else | |
4113 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4114 }else | |
4115 h->implicit_weight[ref0][ref1] = 32; | |
4116 } | |
4117 } | |
4118 } | |
4119 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4120 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
|
4121 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4122 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4123 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
|
4124 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4125 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4126 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
|
4127 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
|
4128 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4129 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4130 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4131 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4132 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4133 |
1168 | 4134 /** |
2392 | 4135 * instantaneous decoder refresh. |
1168 | 4136 */ |
4137 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
|
4138 int i; |
1168 | 4139 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4140 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4141 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
|
4142 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
|
4143 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4144 } |
1168 | 4145 } |
4146 h->long_ref_count=0; | |
4147 | |
4148 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
|
4149 unreference_pic(h, h->short_ref[i]); |
1168 | 4150 h->short_ref[i]= NULL; |
4151 } | |
4152 h->short_ref_count=0; | |
4153 } | |
4154 | |
2640 | 4155 /* forget old pics after a seek */ |
4156 static void flush_dpb(AVCodecContext *avctx){ | |
4157 H264Context *h= avctx->priv_data; | |
4158 int i; | |
3144 | 4159 for(i=0; i<16; i++) { |
4160 if(h->delayed_pic[i]) | |
4161 h->delayed_pic[i]->reference= 0; | |
2640 | 4162 h->delayed_pic[i]= NULL; |
3144 | 4163 } |
4164 if(h->delayed_output_pic) | |
4165 h->delayed_output_pic->reference= 0; | |
2640 | 4166 h->delayed_output_pic= NULL; |
4167 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4168 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4169 h->s.current_picture_ptr->reference= 0; |
2640 | 4170 } |
4171 | |
1168 | 4172 /** |
4173 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4174 * @return the removed picture or NULL if an error occurs |
1168 | 4175 */ |
4176 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4177 MpegEncContext * const s = &h->s; |
1168 | 4178 int i; |
2967 | 4179 |
1169 | 4180 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
|
4181 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4182 |
1168 | 4183 for(i=0; i<h->short_ref_count; i++){ |
4184 Picture *pic= h->short_ref[i]; | |
1169 | 4185 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
|
4186 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4187 if(pic->frame_num == frame_num){ |
4188 h->short_ref[i]= NULL; | |
4189 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4190 h->short_ref_count--; | |
4191 return pic; | |
4192 } | |
4193 } | |
4194 return NULL; | |
4195 } | |
4196 | |
4197 /** | |
4198 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4199 * @return the removed picture or NULL if an error occurs |
1168 | 4200 */ |
4201 static Picture * remove_long(H264Context *h, int i){ | |
4202 Picture *pic; | |
4203 | |
4204 pic= h->long_ref[i]; | |
4205 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
|
4206 if(pic) h->long_ref_count--; |
1168 | 4207 |
4208 return pic; | |
4209 } | |
4210 | |
4211 /** | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4212 * 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
|
4213 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4214 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
|
4215 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
|
4216 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
|
4217 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
|
4218 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
|
4219 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
|
4220 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
|
4221 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4222 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4223 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4224 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4225 /** |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4226 * 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
|
4227 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4228 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
|
4229 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
|
4230 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
|
4231 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
|
4232 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
|
4233 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
|
4234 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
|
4235 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
|
4236 } |
358813ec4ca2
H.264 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 } |
358813ec4ca2
H.264 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 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4239 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4240 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4241 /** |
1168 | 4242 * Executes the reference picture marking (memory management control operations). |
4243 */ | |
4244 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4245 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
|
4246 int i, j; |
1168 | 4247 int current_is_long=0; |
4248 Picture *pic; | |
2967 | 4249 |
1168 | 4250 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
|
4251 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4252 |
1168 | 4253 for(i=0; i<mmco_count; i++){ |
4254 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
|
4255 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 | 4256 |
4257 switch(mmco[i].opcode){ | |
4258 case MMCO_SHORT2UNUSED: | |
4259 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
|
4260 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4261 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4262 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
|
4263 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4264 break; |
4265 case MMCO_SHORT2LONG: | |
4266 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
|
4267 if(pic) unreference_pic(h, pic); |
2967 | 4268 |
1168 | 4269 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
|
4270 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
|
4271 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
|
4272 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4273 } |
1168 | 4274 break; |
4275 case MMCO_LONG2UNUSED: | |
4276 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
|
4277 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4278 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4279 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
|
4280 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4281 break; |
4282 case MMCO_LONG: | |
4283 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
|
4284 if(pic) unreference_pic(h, pic); |
2967 | 4285 |
1168 | 4286 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4287 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4288 h->long_ref_count++; | |
2967 | 4289 |
1168 | 4290 current_is_long=1; |
4291 break; | |
4292 case MMCO_SET_MAX_LONG: | |
4293 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
|
4294 // 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
|
4295 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
|
4296 pic = remove_long(h, j); |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4297 if (pic) unreference_pic(h, pic); |
1168 | 4298 } |
4299 break; | |
4300 case MMCO_RESET: | |
4301 while(h->short_ref_count){ | |
4302 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
|
4303 if(pic) unreference_pic(h, pic); |
1168 | 4304 } |
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
|
4305 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
|
4306 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
|
4307 if(pic) unreference_pic(h, pic); |
1168 | 4308 } |
4309 break; | |
4310 default: assert(0); | |
4311 } | |
4312 } | |
2967 | 4313 |
1168 | 4314 if(!current_is_long){ |
4315 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4316 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4317 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4318 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4319 } |
2967 | 4320 |
1168 | 4321 if(h->short_ref_count) |
1169 | 4322 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4323 | |
4324 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4325 h->short_ref[0]->long_ref=0; |
4326 h->short_ref_count++; | |
4327 } | |
2967 | 4328 |
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
|
4329 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
|
4330 print_long_term(h); |
2967 | 4331 return 0; |
1168 | 4332 } |
4333 | |
4334 static int decode_ref_pic_marking(H264Context *h){ | |
4335 MpegEncContext * const s = &h->s; | |
4336 int i; | |
2967 | 4337 |
1168 | 4338 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4339 s->broken_link= get_bits1(&s->gb) -1; | |
4340 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4341 if(h->mmco[0].long_index == -1) | |
4342 h->mmco_index= 0; | |
4343 else{ | |
4344 h->mmco[0].opcode= MMCO_LONG; | |
4345 h->mmco_index= 1; | |
2967 | 4346 } |
1168 | 4347 }else{ |
4348 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4349 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4350 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4351 | |
4352 h->mmco[i].opcode= opcode; | |
4353 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4354 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 | |
4355 /* 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
|
4356 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4357 return -1; |
4358 }*/ | |
4359 } | |
4360 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
4361 h->mmco[i].long_index= get_ue_golomb(&s->gb); | |
4362 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4363 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4364 return -1; |
4365 } | |
4366 } | |
2967 | 4367 |
1168 | 4368 if(opcode > MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4369 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4370 return -1; |
4371 } | |
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
|
4372 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
|
4373 break; |
1168 | 4374 } |
4375 h->mmco_index= i; | |
4376 }else{ | |
4377 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4378 | |
4379 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4380 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4381 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4382 h->mmco_index= 1; | |
4383 }else | |
4384 h->mmco_index= 0; | |
4385 } | |
4386 } | |
2967 | 4387 |
4388 return 0; | |
1168 | 4389 } |
4390 | |
4391 static int init_poc(H264Context *h){ | |
4392 MpegEncContext * const s = &h->s; | |
4393 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4394 int field_poc[2]; | |
4395 | |
4396 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4397 h->frame_num_offset= 0; | |
4398 }else{ | |
4399 if(h->frame_num < h->prev_frame_num) | |
4400 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4401 else | |
4402 h->frame_num_offset= h->prev_frame_num_offset; | |
4403 } | |
4404 | |
4405 if(h->sps.poc_type==0){ | |
4406 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4407 | |
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
|
4408 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
|
4409 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
|
4410 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
|
4411 } |
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
4412 |
1168 | 4413 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4414 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4415 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4416 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4417 else | |
4418 h->poc_msb = h->prev_poc_msb; | |
4419 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4420 field_poc[0] = |
1168 | 4421 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4422 if(s->picture_structure == PICT_FRAME) |
1168 | 4423 field_poc[1] += h->delta_poc_bottom; |
4424 }else if(h->sps.poc_type==1){ | |
4425 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4426 int i; | |
4427 | |
4428 if(h->sps.poc_cycle_length != 0) | |
4429 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4430 else | |
4431 abs_frame_num = 0; | |
4432 | |
4433 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4434 abs_frame_num--; | |
2967 | 4435 |
1168 | 4436 expected_delta_per_poc_cycle = 0; |
4437 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4438 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4439 | |
4440 if(abs_frame_num > 0){ | |
4441 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4442 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4443 | |
4444 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4445 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4446 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4447 } else | |
4448 expectedpoc = 0; | |
4449 | |
2967 | 4450 if(h->nal_ref_idc == 0) |
1168 | 4451 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4452 |
1168 | 4453 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4454 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4455 | |
4456 if(s->picture_structure == PICT_FRAME) | |
4457 field_poc[1] += h->delta_poc[1]; | |
4458 }else{ | |
4459 int poc; | |
4460 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4461 poc= 0; | |
4462 }else{ | |
4463 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4464 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4465 } | |
4466 field_poc[0]= poc; | |
4467 field_poc[1]= poc; | |
4468 } | |
2967 | 4469 |
1168 | 4470 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4471 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4472 if(s->picture_structure != PICT_TOP_FIELD) | |
4473 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4474 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4475 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4476 | |
4477 return 0; | |
4478 } | |
4479 | |
4480 /** | |
4481 * decodes a slice header. | |
4482 * this will allso call MPV_common_init() and frame_start() as needed | |
4483 */ | |
4484 static int decode_slice_header(H264Context *h){ | |
4485 MpegEncContext * const s = &h->s; | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4486 int first_mb_in_slice; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4487 unsigned int pps_id; |
1168 | 4488 int num_ref_idx_active_override_flag; |
4489 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4490 int slice_type; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4491 int default_ref_list_done = 0; |
1168 | 4492 |
4493 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
|
4494 s->dropable= h->nal_ref_idc == 0; |
1168 | 4495 |
4496 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4497 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4498 slice_type= 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
|
4499 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4500 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 | 4501 return -1; |
1168 | 4502 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4503 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4504 slice_type -= 5; |
1168 | 4505 h->slice_type_fixed=1; |
4506 }else | |
4507 h->slice_type_fixed=0; | |
2967 | 4508 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4509 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
|
4510 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
|
4511 || (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
|
4512 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
|
4513 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4514 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
|
4515 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4516 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4517 |
1168 | 4518 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
|
4519 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4520 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4521 return -1; |
4522 } | |
4523 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4524 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
|
4525 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4526 return -1; |
4527 } | |
4528 | |
1168 | 4529 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4530 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
|
4531 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4532 return -1; |
4533 } | |
2919 | 4534 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4535 if(h->dequant_coeff_pps != (int)pps_id){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4536 h->dequant_coeff_pps = (int)pps_id; |
2919 | 4537 init_dequant_tables(h); |
4538 } | |
2967 | 4539 |
1168 | 4540 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
|
4541 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4542 |
3178 | 4543 h->b_stride= s->mb_width*4; |
4544 h->b8_stride= s->mb_width*2; | |
1168 | 4545 |
1371 | 4546 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4547 if(h->sps.frame_mbs_only_flag) |
1371 | 4548 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4549 else |
1371 | 4550 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4551 |
4552 if (s->context_initialized | |
1548 | 4553 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4554 free_tables(h); |
4555 MPV_common_end(s); | |
4556 } | |
4557 if (!s->context_initialized) { | |
4558 if (MPV_common_init(s) < 0) | |
4559 return -1; | |
2967 | 4560 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4561 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
|
4562 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
|
4563 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
|
4564 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4565 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4566 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4567 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4568 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4569 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4570 #undef T |
4571 } | |
4572 } | |
4573 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4574 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4575 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4576 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4577 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4578 }else{ |
4579 int i; | |
4580 for(i=0; i<64; i++){ | |
4581 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4582 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4583 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4584 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4585 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4586 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4587 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4588 } |
2763 | 4589 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4590 h->zigzag_scan_q0 = zigzag_scan; |
4591 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4592 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4593 h->field_scan_q0 = field_scan; |
4594 h->field_scan8x8_q0 = field_scan8x8; | |
4595 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4596 }else{ |
3316 | 4597 h->zigzag_scan_q0 = h->zigzag_scan; |
4598 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4599 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4600 h->field_scan_q0 = h->field_scan; |
4601 h->field_scan8x8_q0 = h->field_scan8x8; | |
4602 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4603 } |
1168 | 4604 |
4605 alloc_tables(h); | |
4606 | |
4607 s->avctx->width = s->width; | |
4608 s->avctx->height = s->height; | |
1548 | 4609 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4610 if(!s->avctx->sample_aspect_ratio.den) |
4611 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
|
4612 |
2648 | 4613 if(h->sps.timing_info_present_flag){ |
3052 | 4614 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
|
4615 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
|
4616 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4617 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
|
4618 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
|
4619 } |
1168 | 4620 } |
4621 | |
2392 | 4622 if(h->slice_num == 0){ |
2935 | 4623 if(frame_start(h) < 0) |
4624 return -1; | |
1168 | 4625 } |
4626 | |
1169 | 4627 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4628 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4629 | |
3316 | 4630 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4631 h->mb_aff_frame = 0; |
1168 | 4632 if(h->sps.frame_mbs_only_flag){ |
4633 s->picture_structure= PICT_FRAME; | |
4634 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4635 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4636 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4637 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
|
4638 } else { |
1168 | 4639 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4640 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
|
4641 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4642 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4643 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4644 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4645 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame; |
2772 | 4646 if(s->mb_y >= s->mb_height){ |
4647 return -1; | |
4648 } | |
2967 | 4649 |
1168 | 4650 if(s->picture_structure==PICT_FRAME){ |
4651 h->curr_pic_num= h->frame_num; | |
4652 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4653 }else{ | |
4654 h->curr_pic_num= 2*h->frame_num; | |
4655 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4656 } | |
2967 | 4657 |
1168 | 4658 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4659 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4660 } |
2967 | 4661 |
1168 | 4662 if(h->sps.poc_type==0){ |
4663 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4664 |
1168 | 4665 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4666 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4667 } | |
4668 } | |
2967 | 4669 |
1168 | 4670 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4671 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4672 |
1168 | 4673 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4674 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4675 } | |
2967 | 4676 |
1168 | 4677 init_poc(h); |
2967 | 4678 |
1168 | 4679 if(h->pps.redundant_pic_cnt_present){ |
4680 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4681 } | |
4682 | |
4683 //set defaults, might be overriden a few line later | |
4684 h->ref_count[0]= h->pps.ref_count[0]; | |
4685 h->ref_count[1]= h->pps.ref_count[1]; | |
4686 | |
4687 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4688 if(h->slice_type == B_TYPE){ | |
4689 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4690 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4691 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4692 } |
4693 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4694 |
1168 | 4695 if(num_ref_idx_active_override_flag){ |
4696 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4697 if(h->slice_type==B_TYPE) | |
4698 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4699 | |
4700 if(h->ref_count[0] > 32 || h->ref_count[1] > 32){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4701 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
1168 | 4702 return -1; |
4703 } | |
4704 } | |
4705 } | |
4706 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4707 if(!default_ref_list_done){ |
1168 | 4708 fill_default_ref_list(h); |
4709 } | |
4710 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4711 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
|
4712 return -1; |
1168 | 4713 |
2967 | 4714 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4715 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4716 pred_weight_table(h); | |
2415 | 4717 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4718 implicit_weight_table(h); | |
4719 else | |
4720 h->use_weight = 0; | |
2967 | 4721 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4722 if(s->current_picture.reference) |
1168 | 4723 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
|
4724 |
3316 | 4725 if(FRAME_MBAFF) |
4726 fill_mbaff_ref_list(h); | |
4727 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4728 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4729 h->cabac_init_idc = get_ue_golomb(&s->gb); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4730 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4731 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
|
4732 s->qscale = h->pps.init_qp + get_se_golomb(&s->gb); |
1898 | 4733 if(s->qscale<0 || s->qscale>51){ |
4734 av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale); | |
4735 return -1; | |
4736 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4737 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4738 //FIXME qscale / qp ... stuff |
4739 if(h->slice_type == SP_TYPE){ | |
1453 | 4740 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4741 } |
4742 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4743 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4744 } |
4745 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4746 h->deblocking_filter = 1; |
1898 | 4747 h->slice_alpha_c0_offset = 0; |
4748 h->slice_beta_offset = 0; | |
1168 | 4749 if( h->pps.deblocking_filter_parameters_present ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4750 h->deblocking_filter= get_ue_golomb(&s->gb); |
2967 | 4751 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
|
4752 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
|
4753 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4754 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
|
4755 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
|
4756 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4757 } |
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
|
4758 } |
2792 | 4759 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4760 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4761 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4762 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4763 h->deblocking_filter= 0; | |
1168 | 4764 |
4765 #if 0 //FMO | |
4766 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4767 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4768 #endif | |
4769 | |
2392 | 4770 h->slice_num++; |
4771 | |
3316 | 4772 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4773 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4774 | |
1168 | 4775 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
|
4776 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
|
4777 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4778 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4779 first_mb_in_slice, |
1264 | 4780 av_get_pict_type_char(h->slice_type), |
1168 | 4781 pps_id, h->frame_num, |
4782 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4783 h->ref_count[0], h->ref_count[1], | |
4784 s->qscale, | |
2583 | 4785 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4786 h->use_weight, |
4787 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4788 ); |
4789 } | |
4790 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4791 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
|
4792 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
|
4793 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
|
4794 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4795 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
|
4796 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
|
4797 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4798 |
1168 | 4799 return 0; |
4800 } | |
4801 | |
4802 /** | |
4803 * | |
4804 */ | |
4805 static inline int get_level_prefix(GetBitContext *gb){ | |
4806 unsigned int buf; | |
4807 int log; | |
2967 | 4808 |
1168 | 4809 OPEN_READER(re, gb); |
4810 UPDATE_CACHE(re, gb); | |
4811 buf=GET_CACHE(re, gb); | |
2967 | 4812 |
1168 | 4813 log= 32 - av_log2(buf); |
4814 #ifdef TRACE | |
4815 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
|
4816 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 | 4817 #endif |
4818 | |
4819 LAST_SKIP_BITS(re, gb, log); | |
4820 CLOSE_READER(re, gb); | |
4821 | |
4822 return log-1; | |
4823 } | |
4824 | |
2755 | 4825 static inline int get_dct8x8_allowed(H264Context *h){ |
4826 int i; | |
4827 for(i=0; i<4; i++){ | |
4828 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
|
4829 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4830 return 0; |
4831 } | |
4832 return 1; | |
4833 } | |
4834 | |
1168 | 4835 /** |
4836 * decodes a residual block. | |
4837 * @param n block index | |
4838 * @param scantable scantable | |
4839 * @param max_coeff number of coefficients in the block | |
4840 * @return <0 if an error occured | |
4841 */ | |
2919 | 4842 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4843 MpegEncContext * const s = &h->s; |
4844 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 | 4845 int level[16]; |
4846 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4847 |
4848 //FIXME put trailing_onex into the context | |
4849 | |
4850 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4851 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4852 total_coeff= coeff_token>>2; | |
2967 | 4853 }else{ |
1168 | 4854 if(n == LUMA_DC_BLOCK_INDEX){ |
4855 total_coeff= pred_non_zero_count(h, 0); | |
4856 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4857 total_coeff= coeff_token>>2; | |
4858 }else{ | |
4859 total_coeff= pred_non_zero_count(h, n); | |
4860 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4861 total_coeff= coeff_token>>2; | |
4862 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4863 } | |
4864 } | |
4865 | |
4866 //FIXME set last_non_zero? | |
4867 | |
4868 if(total_coeff==0) | |
4869 return 0; | |
4270 | 4870 if(total_coeff<0) { |
4871 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff<0)\n", s->mb_x, s->mb_y); | |
4872 return -1; | |
4873 } | |
2967 | 4874 |
1168 | 4875 trailing_ones= coeff_token&3; |
1170 | 4876 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4877 assert(total_coeff<=16); |
2967 | 4878 |
1168 | 4879 for(i=0; i<trailing_ones; i++){ |
4880 level[i]= 1 - 2*get_bits1(gb); | |
4881 } | |
4882 | |
2897 | 4883 if(i<total_coeff) { |
1168 | 4884 int level_code, mask; |
2897 | 4885 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4886 int prefix= get_level_prefix(gb); | |
4887 | |
4888 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4889 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4890 if(suffix_length) | |
4891 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4892 else | |
4893 level_code= (prefix<<suffix_length); //part | |
4894 }else if(prefix==14){ | |
4895 if(suffix_length) | |
4896 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4897 else | |
4898 level_code= prefix + get_bits(gb, 4); //part | |
4899 }else if(prefix==15){ | |
4900 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
|
4901 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4902 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4903 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4904 return -1; |
4905 } | |
4906 | |
2897 | 4907 if(trailing_ones < 3) level_code += 2; |
4908 | |
4909 suffix_length = 1; | |
4910 if(level_code > 5) | |
4911 suffix_length++; | |
1168 | 4912 mask= -(level_code&1); |
4913 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4914 i++; |
4915 | |
4916 //remaining coefficients have suffix_length > 0 | |
4917 for(;i<total_coeff;i++) { | |
4918 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4919 prefix = get_level_prefix(gb); | |
4920 if(prefix<15){ | |
4921 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4922 }else if(prefix==15){ | |
4923 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4924 }else{ | |
4925 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4926 return -1; | |
4927 } | |
4928 mask= -(level_code&1); | |
4929 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4930 if(level_code > suffix_limit[suffix_length]) | |
4931 suffix_length++; | |
4932 } | |
1168 | 4933 } |
4934 | |
4935 if(total_coeff == max_coeff) | |
4936 zeros_left=0; | |
4937 else{ | |
4938 if(n == CHROMA_DC_BLOCK_INDEX) | |
4939 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4940 else | |
4941 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4942 } | |
2897 | 4943 |
4944 coeff_num = zeros_left + total_coeff - 1; | |
4945 j = scantable[coeff_num]; | |
4946 if(n > 24){ | |
4947 block[j] = level[0]; | |
4948 for(i=1;i<total_coeff;i++) { | |
4949 if(zeros_left <= 0) | |
4950 run_before = 0; | |
4951 else if(zeros_left < 7){ | |
4952 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4953 }else{ | |
4954 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4955 } | |
4956 zeros_left -= run_before; | |
4957 coeff_num -= 1 + run_before; | |
4958 j= scantable[ coeff_num ]; | |
4959 | |
4960 block[j]= level[i]; | |
4961 } | |
4962 }else{ | |
2919 | 4963 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4964 for(i=1;i<total_coeff;i++) { |
4965 if(zeros_left <= 0) | |
4966 run_before = 0; | |
4967 else if(zeros_left < 7){ | |
4968 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4969 }else{ | |
4970 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4971 } | |
4972 zeros_left -= run_before; | |
4973 coeff_num -= 1 + run_before; | |
4974 j= scantable[ coeff_num ]; | |
4975 | |
2919 | 4976 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 4977 } |
1168 | 4978 } |
4979 | |
4980 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4981 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4982 return -1; |
4983 } | |
2897 | 4984 |
1168 | 4985 return 0; |
4986 } | |
4987 | |
3316 | 4988 static void predict_field_decoding_flag(H264Context *h){ |
4989 MpegEncContext * const s = &h->s; | |
4990 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
4991 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
4992 ? s->current_picture.mb_type[mb_xy-1] | |
4993 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
4994 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
4995 : 0; | |
4996 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
4997 } | |
4998 | |
1168 | 4999 /** |
2396 | 5000 * decodes a P_SKIP or B_SKIP macroblock |
5001 */ | |
5002 static void decode_mb_skip(H264Context *h){ | |
5003 MpegEncContext * const s = &h->s; | |
5004 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
|
5005 int mb_type=0; |
2967 | 5006 |
2396 | 5007 memset(h->non_zero_count[mb_xy], 0, 16); |
5008 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
5009 | |
3316 | 5010 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5011 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5012 |
2396 | 5013 if( h->slice_type == B_TYPE ) |
5014 { | |
5015 // 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
|
5016 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5017 |
2449 | 5018 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5019 pred_direct_motion(h, &mb_type); |
3927 | 5020 mb_type|= MB_TYPE_SKIP; |
2396 | 5021 } |
5022 else | |
5023 { | |
5024 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5025 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5026 |
2449 | 5027 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5028 pred_pskip_motion(h, &mx, &my); |
5029 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5030 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5031 } | |
5032 | |
5033 write_back_motion(h, mb_type); | |
3927 | 5034 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5035 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5036 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
|
5037 h->prev_mb_skipped= 1; |
2396 | 5038 } |
5039 | |
5040 /** | |
1168 | 5041 * decodes a macroblock |
5042 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5043 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5044 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5045 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
|
5046 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1169 | 5047 int mb_type, partition_count, cbp; |
2755 | 5048 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5049 |
2967 | 5050 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5051 |
1170 | 5052 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5053 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5054 down the code */ | |
1168 | 5055 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5056 if(s->mb_skip_run==-1) | |
5057 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5058 |
1168 | 5059 if (s->mb_skip_run--) { |
3316 | 5060 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5061 if(s->mb_skip_run==0) | |
5062 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5063 else | |
5064 predict_field_decoding_flag(h); | |
5065 } | |
2396 | 5066 decode_mb_skip(h); |
1168 | 5067 return 0; |
5068 } | |
5069 } | |
3316 | 5070 if(FRAME_MBAFF){ |
5071 if( (s->mb_y&1) == 0 ) | |
5072 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5073 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5074 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5075 |
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
|
5076 h->prev_mb_skipped= 0; |
2967 | 5077 |
1168 | 5078 mb_type= get_ue_golomb(&s->gb); |
5079 if(h->slice_type == B_TYPE){ | |
5080 if(mb_type < 23){ | |
5081 partition_count= b_mb_type_info[mb_type].partition_count; | |
5082 mb_type= b_mb_type_info[mb_type].type; | |
5083 }else{ | |
5084 mb_type -= 23; | |
5085 goto decode_intra_mb; | |
5086 } | |
5087 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5088 if(mb_type < 5){ | |
5089 partition_count= p_mb_type_info[mb_type].partition_count; | |
5090 mb_type= p_mb_type_info[mb_type].type; | |
5091 }else{ | |
5092 mb_type -= 5; | |
5093 goto decode_intra_mb; | |
5094 } | |
5095 }else{ | |
5096 assert(h->slice_type == I_TYPE); | |
5097 decode_intra_mb: | |
5098 if(mb_type > 25){ | |
3954 | 5099 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 | 5100 return -1; |
5101 } | |
5102 partition_count=0; | |
5103 cbp= i_mb_type_info[mb_type].cbp; | |
5104 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5105 mb_type= i_mb_type_info[mb_type].type; | |
5106 } | |
5107 | |
3316 | 5108 if(MB_FIELD) |
1168 | 5109 mb_type |= MB_TYPE_INTERLACED; |
5110 | |
5111 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5112 |
1168 | 5113 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5114 unsigned int x, y; |
2967 | 5115 |
1168 | 5116 // we assume these blocks are very rare so we dont optimize it |
5117 align_get_bits(&s->gb); | |
2967 | 5118 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5119 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5120 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5121 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5122 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5123 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
|
5124 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5125 } |
5126 } | |
5127 for(y=0; y<8; y++){ | |
5128 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5129 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5130 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
|
5131 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5132 } |
5133 } | |
5134 for(y=0; y<8; y++){ | |
5135 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5136 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5137 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
|
5138 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5139 } |
5140 } | |
2967 | 5141 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5142 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5143 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
|
5144 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
|
5145 // 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
|
5146 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5147 |
2755 | 5148 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5149 return 0; |
5150 } | |
2967 | 5151 |
3316 | 5152 if(MB_MBAFF){ |
5153 h->ref_count[0] <<= 1; | |
5154 h->ref_count[1] <<= 1; | |
5155 } | |
5156 | |
2449 | 5157 fill_caches(h, mb_type, 0); |
1168 | 5158 |
5159 //mb_pred | |
5160 if(IS_INTRA(mb_type)){ | |
5161 // init_top_left_availability(h); | |
5162 if(IS_INTRA4x4(mb_type)){ | |
5163 int i; | |
2755 | 5164 int di = 1; |
5165 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5166 mb_type |= MB_TYPE_8x8DCT; | |
5167 di = 4; | |
5168 } | |
1168 | 5169 |
5170 // fill_intra4x4_pred_table(h); | |
2755 | 5171 for(i=0; i<16; i+=di){ |
3409 | 5172 int mode= pred_intra_mode(h, i); |
5173 | |
5174 if(!get_bits1(&s->gb)){ | |
1168 | 5175 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5176 mode = rem_mode + (rem_mode >= mode); |
1168 | 5177 } |
2967 | 5178 |
2755 | 5179 if(di==4) |
5180 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5181 else | |
5182 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5183 } |
5184 write_back_intra_pred_mode(h); | |
5185 if( check_intra4x4_pred_mode(h) < 0) | |
5186 return -1; | |
5187 }else{ | |
5188 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5189 if(h->intra16x16_pred_mode < 0) | |
5190 return -1; | |
5191 } | |
5192 h->chroma_pred_mode= get_ue_golomb(&s->gb); | |
5193 | |
5194 h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode); | |
5195 if(h->chroma_pred_mode < 0) | |
5196 return -1; | |
5197 }else if(partition_count==4){ | |
5198 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5199 |
1168 | 5200 if(h->slice_type == B_TYPE){ |
5201 for(i=0; i<4; i++){ | |
5202 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5203 if(h->sub_mb_type[i] >=13){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5204 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5205 return -1; |
5206 } | |
5207 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5208 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5209 } | |
2396 | 5210 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5211 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5212 pred_direct_motion(h, &mb_type); |
3003 | 5213 h->ref_cache[0][scan8[4]] = |
5214 h->ref_cache[1][scan8[4]] = | |
5215 h->ref_cache[0][scan8[12]] = | |
5216 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5217 } | |
1168 | 5218 }else{ |
5219 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5220 for(i=0; i<4; i++){ | |
5221 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5222 if(h->sub_mb_type[i] >=4){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5223 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5224 return -1; |
5225 } | |
5226 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5227 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5228 } | |
5229 } | |
2967 | 5230 |
1168 | 5231 for(list=0; list<2; list++){ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5232 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5233 if(ref_count == 0) continue; |
5234 for(i=0; i<4; i++){ | |
2396 | 5235 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5236 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1168 | 5237 ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
5238 }else{ | |
5239 //FIXME | |
5240 ref[list][i] = -1; | |
5241 } | |
5242 } | |
5243 } | |
2967 | 5244 |
2755 | 5245 if(dct8x8_allowed) |
5246 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5247 |
1168 | 5248 for(list=0; list<2; list++){ |
5249 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
5250 if(ref_count == 0) continue; | |
5251 | |
5252 for(i=0; i<4; i++){ | |
3003 | 5253 if(IS_DIRECT(h->sub_mb_type[i])) { |
5254 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5255 continue; | |
5256 } | |
1168 | 5257 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5258 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5259 | |
2396 | 5260 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5261 const int sub_mb_type= h->sub_mb_type[i]; |
5262 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5263 for(j=0; j<sub_partition_count[i]; j++){ | |
5264 int mx, my; | |
5265 const int index= 4*i + block_width*j; | |
5266 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5267 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5268 mx += get_se_golomb(&s->gb); | |
5269 my += get_se_golomb(&s->gb); | |
1170 | 5270 tprintf("final mv:%d %d\n", mx, my); |
5271 | |
1168 | 5272 if(IS_SUB_8X8(sub_mb_type)){ |
2967 | 5273 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
1168 | 5274 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
2967 | 5275 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
1168 | 5276 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5277 }else if(IS_SUB_8X4(sub_mb_type)){ | |
5278 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; | |
5279 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; | |
5280 }else if(IS_SUB_4X8(sub_mb_type)){ | |
5281 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; | |
5282 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; | |
5283 }else{ | |
5284 assert(IS_SUB_4X4(sub_mb_type)); | |
5285 mv_cache[ 0 ][0]= mx; | |
5286 mv_cache[ 0 ][1]= my; | |
5287 } | |
5288 } | |
5289 }else{ | |
5290 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5291 p[0] = p[1]= | |
5292 p[8] = p[9]= 0; | |
5293 } | |
5294 } | |
5295 } | |
2396 | 5296 }else if(IS_DIRECT(mb_type)){ |
5297 pred_direct_motion(h, &mb_type); | |
2755 | 5298 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5299 }else{ |
1168 | 5300 int list, mx, my, i; |
5301 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5302 if(IS_16X16(mb_type)){ | |
5303 for(list=0; list<2; list++){ | |
2392 | 5304 if(h->ref_count[list]>0){ |
1168 | 5305 if(IS_DIR(mb_type, 0, list)){ |
5306 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5307 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
2523 | 5308 }else |
5309 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 5310 } |
5311 } | |
5312 for(list=0; list<2; list++){ | |
5313 if(IS_DIR(mb_type, 0, list)){ | |
5314 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &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 | |
1269 | 5319 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5320 }else |
5321 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1168 | 5322 } |
5323 } | |
5324 else if(IS_16X8(mb_type)){ | |
5325 for(list=0; list<2; list++){ | |
5326 if(h->ref_count[list]>0){ | |
5327 for(i=0; i<2; i++){ | |
5328 if(IS_DIR(mb_type, i, list)){ | |
5329 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5330 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
2523 | 5331 }else |
2396 | 5332 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5333 } |
5334 } | |
5335 } | |
5336 for(list=0; list<2; list++){ | |
5337 for(i=0; i<2; i++){ | |
5338 if(IS_DIR(mb_type, i, list)){ | |
5339 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5340 mx += get_se_golomb(&s->gb); | |
5341 my += get_se_golomb(&s->gb); | |
1170 | 5342 tprintf("final mv:%d %d\n", mx, my); |
5343 | |
1269 | 5344 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5345 }else |
5346 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 5347 } |
5348 } | |
5349 }else{ | |
5350 assert(IS_8X16(mb_type)); | |
5351 for(list=0; list<2; list++){ | |
5352 if(h->ref_count[list]>0){ | |
5353 for(i=0; i<2; i++){ | |
5354 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
5355 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5356 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
2523 | 5357 }else |
2396 | 5358 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5359 } |
5360 } | |
5361 } | |
5362 for(list=0; list<2; list++){ | |
5363 for(i=0; i<2; i++){ | |
5364 if(IS_DIR(mb_type, i, list)){ | |
5365 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5366 mx += get_se_golomb(&s->gb); | |
5367 my += get_se_golomb(&s->gb); | |
1170 | 5368 tprintf("final mv:%d %d\n", mx, my); |
5369 | |
1269 | 5370 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5371 }else |
5372 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 5373 } |
5374 } | |
5375 } | |
5376 } | |
2967 | 5377 |
1168 | 5378 if(IS_INTER(mb_type)) |
5379 write_back_motion(h, mb_type); | |
2967 | 5380 |
1168 | 5381 if(!IS_INTRA16x16(mb_type)){ |
5382 cbp= get_ue_golomb(&s->gb); | |
5383 if(cbp > 47){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5384 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5385 return -1; |
5386 } | |
2967 | 5387 |
1168 | 5388 if(IS_INTRA4x4(mb_type)) |
5389 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5390 else | |
5391 cbp= golomb_to_inter_cbp[cbp]; | |
5392 } | |
3651 | 5393 h->cbp = cbp; |
1168 | 5394 |
2755 | 5395 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5396 if(get_bits1(&s->gb)) | |
5397 mb_type |= MB_TYPE_8x8DCT; | |
5398 } | |
5399 s->current_picture.mb_type[mb_xy]= mb_type; | |
5400 | |
1168 | 5401 if(cbp || IS_INTRA16x16(mb_type)){ |
5402 int i8x8, i4x4, chroma_idx; | |
5403 int chroma_qp, dquant; | |
5404 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5405 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5406 |
1168 | 5407 // fill_non_zero_count_cache(h); |
5408 | |
5409 if(IS_INTERLACED(mb_type)){ | |
3316 | 5410 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5411 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5412 dc_scan= luma_dc_field_scan; |
5413 }else{ | |
3316 | 5414 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5415 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5416 dc_scan= luma_dc_zigzag_scan; |
5417 } | |
5418 | |
5419 dquant= get_se_golomb(&s->gb); | |
5420 | |
5421 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5422 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 | 5423 return -1; |
5424 } | |
2967 | 5425 |
1168 | 5426 s->qscale += dquant; |
5427 if(((unsigned)s->qscale) > 51){ | |
5428 if(s->qscale<0) s->qscale+= 52; | |
5429 else s->qscale-= 52; | |
5430 } | |
2967 | 5431 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5432 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5433 if(IS_INTRA16x16(mb_type)){ |
2919 | 5434 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
|
5435 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5436 } |
5437 | |
5438 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5439 | |
5440 if(cbp&15){ | |
5441 for(i8x8=0; i8x8<4; i8x8++){ | |
5442 for(i4x4=0; i4x4<4; i4x4++){ | |
5443 const int index= i4x4 + 4*i8x8; | |
2919 | 5444 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5445 return -1; |
5446 } | |
5447 } | |
5448 } | |
5449 }else{ | |
1636 | 5450 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5451 } |
5452 }else{ | |
5453 for(i8x8=0; i8x8<4; i8x8++){ | |
5454 if(cbp & (1<<i8x8)){ | |
2755 | 5455 if(IS_8x8DCT(mb_type)){ |
5456 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5457 uint8_t *nnz; |
2755 | 5458 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5459 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5460 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5461 return -1; |
5462 } | |
2757 | 5463 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
|
5464 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5465 }else{ |
5466 for(i4x4=0; i4x4<4; i4x4++){ | |
5467 const int index= i4x4 + 4*i8x8; | |
2967 | 5468 |
2919 | 5469 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 | 5470 return -1; |
5471 } | |
1168 | 5472 } |
5473 } | |
5474 }else{ | |
5475 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5476 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5477 } | |
5478 } | |
5479 } | |
2967 | 5480 |
1168 | 5481 if(cbp&0x30){ |
5482 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5483 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5484 return -1; |
5485 } | |
5486 } | |
5487 | |
5488 if(cbp&0x20){ | |
5489 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5490 for(i4x4=0; i4x4<4; i4x4++){ | |
5491 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5492 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 | 5493 return -1; |
5494 } | |
5495 } | |
5496 } | |
5497 }else{ | |
5498 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5499 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5500 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5501 } | |
5502 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5503 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
|
5504 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
|
5505 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
|
5506 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5507 } |
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
|
5508 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5509 write_back_non_zero_count(h); |
5510 | |
3316 | 5511 if(MB_MBAFF){ |
5512 h->ref_count[0] >>= 1; | |
5513 h->ref_count[1] >>= 1; | |
5514 } | |
5515 | |
1168 | 5516 return 0; |
5517 } | |
5518 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5519 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
|
5520 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
|
5521 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
|
5522 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
|
5523 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
|
5524 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
|
5525 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5526 unsigned int ctx = 0; |
2967 | 5527 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5528 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
|
5529 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5530 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5531 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
|
5532 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5533 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5534 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5535 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
|
5536 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5537 |
2312 | 5538 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5539 uint8_t *state= &h->cabac_state[ctx_base]; | |
5540 int mb_type; | |
2967 | 5541 |
2312 | 5542 if(intra_slice){ |
5543 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
|
5544 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
|
5545 const int mbb_xy = h->top_mb_xy; |
2312 | 5546 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5547 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
|
5548 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5549 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
|
5550 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5551 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5552 return 0; /* I4x4 */ |
5553 state += 2; | |
5554 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5555 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
|
5556 return 0; /* I4x4 */ |
2312 | 5557 } |
5558 | |
5559 if( get_cabac_terminate( &h->cabac ) ) | |
5560 return 25; /* PCM */ | |
5561 | |
5562 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
|
5563 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
|
5564 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
|
5565 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
|
5566 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
|
5567 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5568 return mb_type; |
5569 } | |
5570 | |
5571 static int decode_cabac_mb_type( H264Context *h ) { | |
5572 MpegEncContext * const s = &h->s; | |
5573 | |
5574 if( h->slice_type == I_TYPE ) { | |
5575 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
|
5576 } 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
|
5577 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
|
5578 /* 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
|
5579 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5580 /* 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
|
5581 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
|
5582 } else { |
3138 | 5583 /* 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
|
5584 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
|
5585 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5586 } else { |
2312 | 5587 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
|
5588 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5589 } 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
|
5590 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
|
5591 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
|
5592 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
|
5593 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5594 |
3138 | 5595 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
|
5596 ctx++; |
3138 | 5597 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
|
5598 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5599 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5600 if( !get_cabac_noinline( &h->cabac, &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
|
5601 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
|
5602 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5603 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
|
5604 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
|
5605 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5606 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5607 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
|
5608 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
|
5609 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
|
5610 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
|
5611 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
|
5612 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
|
5613 else if( bits == 13 ) { |
2312 | 5614 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
|
5615 } 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
|
5616 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
|
5617 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
|
5618 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
|
5619 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5620 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
|
5621 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
|
5622 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5623 /* 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
|
5624 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
|
5625 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5626 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5627 |
3316 | 5628 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
|
5629 MpegEncContext * const s = &h->s; |
3316 | 5630 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
|
5631 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
|
5632 |
3316 | 5633 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5634 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5635 mba_xy = mb_xy - 1; | |
5636 if( (mb_y&1) | |
5637 && h->slice_table[mba_xy] == h->slice_num | |
5638 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5639 mba_xy += s->mb_stride; | |
5640 if( MB_FIELD ){ | |
5641 mbb_xy = mb_xy - s->mb_stride; | |
5642 if( !(mb_y&1) | |
5643 && h->slice_table[mbb_xy] == h->slice_num | |
5644 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5645 mbb_xy -= s->mb_stride; | |
5646 }else | |
5647 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5648 }else{ | |
5649 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5650 mba_xy = mb_xy - 1; | |
5651 mbb_xy = mb_xy - s->mb_stride; | |
5652 } | |
5653 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5654 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
|
5655 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5656 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
|
5657 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5658 |
3138 | 5659 if( h->slice_type == B_TYPE ) |
5660 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
|
5661 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
|
5662 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5663 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5664 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
|
5665 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
|
5666 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5667 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
|
5668 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
|
5669 |
2928 | 5670 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5671 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5672 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5673 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5674 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
|
5675 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
|
5676 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5677 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
|
5678 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5679 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5680 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
|
5681 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
|
5682 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
|
5683 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5684 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
|
5685 |
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
|
5686 /* 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
|
5687 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
|
5688 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
|
5689 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5690 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
|
5691 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5692 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5693 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
|
5694 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
|
5695 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5696 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
|
5697 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
|
5698 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
|
5699 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
|
5700 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5701 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
|
5702 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5703 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5704 static 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
|
5705 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
|
5706 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5707 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
|
5708 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
|
5709 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5710 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
|
5711 { 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
|
5712 { 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
|
5713 { 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
|
5714 { 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
|
5715 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5716 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5717 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
|
5718 int cbp = 0; |
3138 | 5719 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
|
5720 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
|
5721 |
3138 | 5722 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5723 cbp_b = h->top_cbp; | |
5724 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5725 } | |
5726 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5727 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
|
5728 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
|
5729 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
|
5730 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
|
5731 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5732 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
|
5733 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
|
5734 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5735 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
|
5736 cbp_a = cbp; |
3138 | 5737 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
|
5738 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
|
5739 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
|
5740 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5741 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5742 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
|
5743 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
|
5744 |
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
|
5745 /* 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
|
5746 /* 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
|
5747 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
|
5748 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
|
5749 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
|
5750 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5751 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5752 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5753 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
|
5754 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
|
5755 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
|
5756 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
|
5757 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5758 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5759 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
|
5760 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
|
5761 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5762 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5763 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
|
5764 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5765 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
|
5766 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
|
5767 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
|
5768 |
2314 | 5769 cbp_a = (h->left_cbp>>4)&0x03; |
5770 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
|
5771 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5772 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
|
5773 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
|
5774 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
|
5775 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
|
5776 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
|
5777 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5778 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
|
5779 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
|
5780 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
|
5781 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
|
5782 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5783 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
|
5784 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
|
5785 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
|
5786 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
|
5787 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
|
5788 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5789 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
|
5790 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
|
5791 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5792 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
|
5793 |
3316 | 5794 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
|
5795 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5796 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5797 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
|
5798 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
|
5799 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
|
5800 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5801 ctx = 3; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5802 val++; |
3128 | 5803 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5804 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
|
5805 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5806 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5807 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
|
5808 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
|
5809 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5810 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
|
5811 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5812 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
|
5813 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
|
5814 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
|
5815 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
|
5816 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
|
5817 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
|
5818 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
|
5819 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
|
5820 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5821 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
|
5822 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5823 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
|
5824 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
|
5825 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
|
5826 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
|
5827 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5828 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
|
5829 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
|
5830 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
|
5831 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5832 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5833 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
|
5834 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
|
5835 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5836 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5837 |
2755 | 5838 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
|
5839 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5840 } |
5841 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5842 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
|
5843 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
|
5844 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
|
5845 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
|
5846 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
|
5847 |
2396 | 5848 if( h->slice_type == B_TYPE) { |
5849 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5850 ctx++; | |
5851 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5852 ctx += 2; | |
5853 } else { | |
5854 if( refa > 0 ) | |
5855 ctx++; | |
5856 if( refb > 0 ) | |
5857 ctx += 2; | |
5858 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5859 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5860 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
|
5861 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5862 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
|
5863 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5864 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5865 ctx = 5; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5866 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5867 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5868 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5869 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5870 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
|
5871 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
|
5872 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
|
5873 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5874 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
|
5875 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5876 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
|
5877 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5878 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
|
5879 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5880 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5881 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5882 |
2317 | 5883 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5884 return 0; | |
5885 | |
5886 mvd= 1; | |
5887 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
|
5888 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
|
5889 mvd++; |
2317 | 5890 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
|
5891 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5892 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5893 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5894 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
|
5895 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
|
5896 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
|
5897 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
|
5898 k++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5899 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5900 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5901 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
|
5902 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
|
5903 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5904 } |
4042 | 5905 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
|
5906 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5907 |
2316 | 5908 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5909 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
|
5910 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
|
5911 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5912 if( cat == 0 ) { |
2314 | 5913 nza = h->left_cbp&0x100; |
5914 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
|
5915 } else if( cat == 1 || cat == 2 ) { |
2314 | 5916 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5917 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
|
5918 } else if( cat == 3 ) { |
2314 | 5919 nza = (h->left_cbp>>(6+idx))&0x01; |
5920 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5921 } else { | |
5922 assert(cat == 4); | |
5923 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5924 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5925 } | |
5926 | |
5927 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
|
5928 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5929 |
2314 | 5930 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
|
5931 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
|
5932 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5933 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
|
5934 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5935 |
4051 | 5936 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
5937 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
5938 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
5939 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
5940 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
5941 }; | |
5942 | |
3028 | 5943 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
|
5944 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5945 static const int significant_coeff_flag_offset[2][6] = { |
5946 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
5947 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
5948 }; | |
5949 static const int last_coeff_flag_offset[2][6] = { | |
5950 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
5951 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
5952 }; | |
5953 static const int coeff_abs_level_m1_offset[6] = { | |
5954 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
5955 }; | |
4007 | 5956 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 5957 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 5958 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
5959 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 5960 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
5961 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
5962 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
5963 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
5964 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 5965 }; |
5966 | |
5967 int index[64]; | |
2313 | 5968 |
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
|
5969 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
|
5970 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
|
5971 |
2316 | 5972 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
|
5973 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
|
5974 |
2898 | 5975 uint8_t *significant_coeff_ctx_base; |
5976 uint8_t *last_coeff_ctx_base; | |
5977 uint8_t *abs_level_m1_ctx_base; | |
2755 | 5978 |
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
|
5979 #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
|
5980 #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
|
5981 #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
|
5982 #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
|
5983 #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
|
5984 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
|
5985 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
|
5986 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
|
5987 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
|
5988 #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
|
5989 #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
|
5990 #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
|
5991 |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5992 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5993 /* 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
|
5994 * 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
|
5995 * 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
|
5996 * 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
|
5997 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 5998 * 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
|
5999 */ |
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 /* read coded block flag */ |
2898 | 6002 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
|
6003 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 6004 if( cat == 1 || cat == 2 ) |
6005 h->non_zero_count_cache[scan8[n]] = 0; | |
6006 else if( cat == 4 ) | |
6007 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
|
6008 #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
|
6009 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
|
6010 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
|
6011 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
|
6012 #endif |
2755 | 6013 return 0; |
6014 } | |
2898 | 6015 } |
6016 | |
6017 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6018 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6019 last_coeff_ctx_base = h->cabac_state |
3316 | 6020 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6021 abs_level_m1_ctx_base = h->cabac_state |
6022 + coeff_abs_level_m1_offset[cat]; | |
6023 | |
6024 if( cat == 5 ) { | |
6025 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6026 for(last= 0; last < coefs; last++) { \ | |
6027 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
|
6028 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6029 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6030 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
|
6031 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6032 last= max_coeff; \ |
6033 break; \ | |
6034 } \ | |
6035 } \ | |
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
|
6036 }\ |
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
|
6037 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
|
6038 index[coeff_count++] = last;\ |
2898 | 6039 } |
4009 | 6040 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
|
6041 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6042 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6043 } else { | |
6044 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6045 #else | |
3316 | 6046 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6047 } else { |
6048 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
|
6049 #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
|
6050 } |
2316 | 6051 assert(coeff_count > 0); |
6052 | |
6053 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
|
6054 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
|
6055 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
|
6056 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6057 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
|
6058 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6059 else if( cat == 4 ) |
6060 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6061 else { |
2755 | 6062 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6063 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6064 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6065 |
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
|
6066 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6067 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
|
6068 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
|
6069 |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
6070 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6071 if( !qmul ) { |
4040 | 6072 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6073 }else{ |
4040 | 6074 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6075 } |
2967 | 6076 |
2313 | 6077 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
|
6078 } else { |
2313 | 6079 int coeff_abs = 2; |
2898 | 6080 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
|
6081 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6082 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
|
6083 } |
2313 | 6084 |
6085 if( coeff_abs >= 15 ) { | |
6086 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
|
6087 while( get_cabac_bypass( CC ) ) { |
2313 | 6088 j++; |
6089 } | |
2967 | 6090 |
4016 | 6091 coeff_abs=1; |
2313 | 6092 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
|
6093 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6094 } |
4016 | 6095 coeff_abs+= 14; |
2313 | 6096 } |
6097 | |
2898 | 6098 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
|
6099 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6100 else block[j] = coeff_abs; |
6101 }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
|
6102 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6103 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6104 } |
2967 | 6105 |
2313 | 6106 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
|
6107 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6108 } |
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
|
6109 #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
|
6110 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
|
6111 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
|
6112 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
|
6113 #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
|
6114 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
|
6115 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6116 |
3077 | 6117 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
|
6118 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6119 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
|
6120 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
|
6121 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
|
6122 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6123 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
|
6124 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
|
6125 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
|
6126 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
|
6127 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6128 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
|
6129 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
|
6130 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6131 ? !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
|
6132 : (!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
|
6133 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6134 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
|
6135 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6136 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
|
6137 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
|
6138 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6139 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6140 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6141 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6142 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6143 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6144 * 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
|
6145 * @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
|
6146 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6147 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
|
6148 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
|
6149 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
|
6150 int mb_type, partition_count, cbp = 0; |
2755 | 6151 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
|
6152 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6153 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
|
6154 |
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
|
6155 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
|
6156 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6157 int skip; |
6158 /* a skipped mb needs the aff flag from the following mb */ | |
6159 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6160 predict_field_decoding_flag(h); | |
6161 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6162 skip = h->next_mb_skipped; | |
6163 else | |
6164 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
|
6165 /* read skip flags */ |
3316 | 6166 if( skip ) { |
6167 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6168 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6169 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6170 if(h->next_mb_skipped) | |
6171 predict_field_decoding_flag(h); | |
6172 else | |
6173 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6174 } | |
6175 | |
2396 | 6176 decode_mb_skip(h); |
6177 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6178 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
|
6179 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
|
6180 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
|
6181 |
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6185 } |
3316 | 6186 if(FRAME_MBAFF){ |
6187 if( (s->mb_y&1) == 0 ) | |
6188 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
|
6189 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
|
6190 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6191 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
|
6192 |
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
|
6193 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
|
6194 |
3077 | 6195 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
|
6196 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
|
6197 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
|
6198 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
|
6199 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6200 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6201 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
|
6202 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
|
6203 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
|
6204 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
|
6205 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6206 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
|
6207 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
|
6208 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6209 } 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
|
6210 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
|
6211 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
|
6212 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
|
6213 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6214 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
|
6215 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
|
6216 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6217 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6218 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
|
6219 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
|
6220 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
|
6221 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
|
6222 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
|
6223 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
|
6224 } |
3316 | 6225 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
|
6226 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
|
6227 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6228 h->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
|
6229 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6230 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6231 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6232 unsigned int x, y; |
2967 | 6233 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6234 // 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
|
6235 // 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
|
6236 // 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
|
6237 ptr= h->cabac.bytestream; |
4344 | 6238 if(h->cabac.low&0x1) ptr--; |
6239 if(CABAC_BITS==16){ | |
6240 if(h->cabac.low&0x1FF) ptr--; | |
6241 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6242 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6243 // 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
|
6244 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6245 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
|
6246 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6247 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6248 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
|
6249 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6250 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6251 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6252 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
|
6253 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6254 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
|
6255 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
|
6256 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6257 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6258 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6259 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
|
6260 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6261 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
|
6262 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
|
6263 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6264 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6265 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6266 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
|
6267 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6268 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6269 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
|
6270 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
|
6271 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6272 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
|
6273 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
|
6274 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6275 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6276 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
|
6277 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
|
6278 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6279 |
3316 | 6280 if(MB_MBAFF){ |
6281 h->ref_count[0] <<= 1; | |
6282 h->ref_count[1] <<= 1; | |
6283 } | |
6284 | |
2449 | 6285 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
|
6286 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6287 if( IS_INTRA( mb_type ) ) { |
2755 | 6288 int i; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6289 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6290 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6291 mb_type |= MB_TYPE_8x8DCT; | |
6292 for( i = 0; i < 16; i+=4 ) { | |
6293 int pred = pred_intra_mode( h, i ); | |
6294 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6295 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6296 } | |
6297 } else { | |
6298 for( i = 0; i < 16; i++ ) { | |
6299 int pred = pred_intra_mode( h, i ); | |
6300 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
|
6301 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6302 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6303 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6304 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6305 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
|
6306 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
|
6307 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6308 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
|
6309 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
|
6310 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6311 h->chroma_pred_mode_table[mb_xy] = |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6312 h->chroma_pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6313 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6314 h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6315 if( h->chroma_pred_mode < 0 ) return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6316 } 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
|
6317 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
|
6318 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6319 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
|
6320 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
|
6321 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
|
6322 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
|
6323 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
|
6324 } |
3482 | 6325 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6326 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6327 pred_direct_motion(h, &mb_type); |
6328 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6329 for( i = 0; i < 4; i++ ) | |
6330 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6331 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6332 } | |
6333 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6334 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6335 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
|
6336 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
|
6337 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
|
6338 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
|
6339 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6340 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6341 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6342 for( list = 0; list < 2; list++ ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6343 if( h->ref_count[list] > 0 ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6344 for( i = 0; i < 4; i++ ) { |
2396 | 6345 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6346 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
|
6347 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
|
6348 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
|
6349 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6350 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
|
6351 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6352 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
|
6353 } |
2110 | 6354 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
|
6355 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
|
6356 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6357 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6358 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6359 |
2755 | 6360 if(dct8x8_allowed) |
6361 dct8x8_allowed = get_dct8x8_allowed(h); | |
6362 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6363 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6364 for(i=0; i<4; i++){ |
2396 | 6365 if(IS_DIRECT(h->sub_mb_type[i])){ |
6366 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6367 continue; | |
6368 } | |
2110 | 6369 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
|
6370 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6371 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
|
6372 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
|
6373 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
|
6374 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
|
6375 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
|
6376 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
|
6377 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
|
6378 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
|
6379 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
|
6380 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
|
6381 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6382 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
|
6383 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
|
6384 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
|
6385 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6386 if(IS_SUB_8X8(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6387 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6388 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6389 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6390 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
|
6391 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6392 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6393 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6394 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6395 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
|
6396 }else if(IS_SUB_8X4(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6397 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6398 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6399 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6400 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6401 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6402 }else if(IS_SUB_4X8(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6403 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6404 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6405 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6406 mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6407 mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6408 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6409 assert(IS_SUB_4X4(sub_mb_type)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6410 mv_cache[ 0 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6411 mv_cache[ 0 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6412 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6413 mvd_cache[ 0 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6414 mvd_cache[ 0 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6415 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6416 } |
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 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
|
6419 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
|
6420 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
|
6421 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
|
6422 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6423 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6424 } |
2396 | 6425 } else if( IS_DIRECT(mb_type) ) { |
6426 pred_direct_motion(h, &mb_type); | |
6427 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6428 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6429 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6430 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6431 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
|
6432 if(IS_16X16(mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6433 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6434 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
|
6435 if(h->ref_count[list] > 0 ){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6436 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
|
6437 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6438 } |
2523 | 6439 }else |
6440 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6441 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6442 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6443 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
|
6444 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
|
6445 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6446 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
|
6447 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
|
6448 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
|
6449 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6450 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
|
6451 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6452 }else |
6453 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
|
6454 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6455 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6456 else if(IS_16X8(mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6457 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6458 if(h->ref_count[list]>0){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6459 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
|
6460 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
|
6461 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
|
6462 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6463 }else |
6464 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
|
6465 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6466 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6467 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6468 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6469 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
|
6470 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
|
6471 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
|
6472 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
|
6473 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
|
6474 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
|
6475 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6476 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
|
6477 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6478 }else{ |
2396 | 6479 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6480 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
|
6481 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6482 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6483 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6484 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6485 assert(IS_8X16(mb_type)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6486 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6487 if(h->ref_count[list]>0){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6488 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
|
6489 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
|
6490 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
|
6491 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6492 }else |
6493 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
|
6494 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6495 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6496 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6497 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6498 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
|
6499 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
|
6500 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
|
6501 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
|
6502 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
|
6503 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6504 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
|
6505 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
|
6506 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6507 }else{ |
2396 | 6508 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6509 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
|
6510 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6511 } |
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 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6514 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6515 |
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
|
6516 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
|
6517 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
|
6518 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
|
6519 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6520 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6521 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
|
6522 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
|
6523 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
|
6524 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6525 |
3651 | 6526 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
|
6527 |
2755 | 6528 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6529 if( decode_cabac_mb_transform_size( h ) ) | |
6530 mb_type |= MB_TYPE_8x8DCT; | |
6531 } | |
6532 s->current_picture.mb_type[mb_xy]= mb_type; | |
6533 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6534 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6535 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
|
6536 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
|
6537 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6538 if(IS_INTERLACED(mb_type)){ |
3316 | 6539 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6540 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
|
6541 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
|
6542 }else{ |
3316 | 6543 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6544 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
|
6545 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
|
6546 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6547 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6548 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
|
6549 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6550 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
|
6551 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6552 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6553 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
|
6554 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
|
6555 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
|
6556 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
|
6557 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6558 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
|
6559 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6560 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
|
6561 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
|
6562 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6563 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
|
6564 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
|
6565 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
|
6566 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
|
6567 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6568 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
|
6569 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
|
6570 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6571 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6572 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
|
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 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6575 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
|
6576 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
|
6577 if( cbp & (1<<i8x8) ) { |
2755 | 6578 if( IS_8x8DCT(mb_type) ) { |
6579 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6580 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6581 return -1; |
6582 } 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
|
6583 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
|
6584 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
|
6585 //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
|
6586 //START_TIMER |
2919 | 6587 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
|
6588 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6589 //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
|
6590 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6591 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6592 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
|
6593 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
|
6594 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6595 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6596 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6597 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6598 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
|
6599 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
|
6600 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
|
6601 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6602 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
|
6603 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6604 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6605 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6606 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6607 if( 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
|
6608 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
|
6609 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
|
6610 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
|
6611 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
|
6612 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6613 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
|
6614 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
|
6615 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6616 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6617 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6618 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
|
6619 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
|
6620 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
|
6621 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6622 } else { |
2315 | 6623 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6624 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6625 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6626 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6627 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
|
6628 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6629 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6630 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
|
6631 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
|
6632 |
3316 | 6633 if(MB_MBAFF){ |
6634 h->ref_count[0] >>= 1; | |
6635 h->ref_count[1] >>= 1; | |
6636 } | |
6637 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6638 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
|
6639 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6640 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6641 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6642 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
|
6643 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
|
6644 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
|
6645 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
|
6646 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
|
6647 |
2633 | 6648 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
|
6649 int8_t tc[4]; |
2633 | 6650 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
|
6651 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6652 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6653 } else { | |
6654 /* 16px edge length, because bS=4 is triggered by being at | |
6655 * the edge of an intra MB, so all 4 bS are the same */ | |
6656 for( d = 0; d < 16; d++ ) { | |
1898 | 6657 const int p0 = pix[-1]; |
6658 const int p1 = pix[-2]; | |
6659 const int p2 = pix[-3]; | |
6660 | |
6661 const int q0 = pix[0]; | |
6662 const int q1 = pix[1]; | |
6663 const int q2 = pix[2]; | |
6664 | |
4001 | 6665 if( FFABS( p0 - q0 ) < alpha && |
6666 FFABS( p1 - p0 ) < beta && | |
6667 FFABS( q1 - q0 ) < beta ) { | |
6668 | |
6669 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6670 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6671 { |
6672 const int p3 = pix[-4]; | |
6673 /* p0', p1', p2' */ | |
6674 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6675 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6676 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6677 } else { | |
6678 /* p0' */ | |
6679 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6680 } | |
4001 | 6681 if( FFABS( q2 - q0 ) < beta) |
1898 | 6682 { |
6683 const int q3 = pix[3]; | |
6684 /* q0', q1', q2' */ | |
6685 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6686 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6687 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6688 } else { | |
6689 /* q0' */ | |
6690 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6691 } | |
6692 }else{ | |
6693 /* p0', q0' */ | |
6694 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6695 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6696 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6697 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
|
6698 } |
1898 | 6699 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
|
6700 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6701 } |
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 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6703 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6704 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6705 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
|
6706 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
|
6707 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
|
6708 |
2633 | 6709 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
|
6710 int8_t tc[4]; |
2633 | 6711 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
|
6712 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6713 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6714 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6715 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
|
6716 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6717 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6718 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6719 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
|
6720 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6721 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
|
6722 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6723 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6724 int beta; |
2967 | 6725 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6726 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6727 int bS_index = (i >> 1); |
3316 | 6728 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6729 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6730 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6731 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6732 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6733 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6734 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6735 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6736 |
3316 | 6737 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
|
6738 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
|
6739 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
|
6740 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
|
6741 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6742 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
|
6743 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
|
6744 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6745 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6746 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6747 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6748 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6749 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6750 |
4001 | 6751 if( FFABS( p0 - q0 ) < alpha && |
6752 FFABS( p1 - p0 ) < beta && | |
6753 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6754 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6755 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6756 |
4001 | 6757 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6758 pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6759 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6760 } |
4001 | 6761 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6762 pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6763 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6764 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6765 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6766 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6767 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6768 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6769 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
|
6770 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6771 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6772 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6773 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6774 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6775 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6776 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6777 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6778 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6779 |
4001 | 6780 if( FFABS( p0 - q0 ) < alpha && |
6781 FFABS( p1 - p0 ) < beta && | |
6782 FFABS( q1 - q0 ) < beta ) { | |
6783 | |
6784 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6785 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6786 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6787 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6788 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6789 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
|
6790 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
|
6791 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
|
6792 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6793 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6794 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
|
6795 } |
4001 | 6796 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6797 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6798 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6799 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6800 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
|
6801 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
|
6802 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
|
6803 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6804 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6805 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
|
6806 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6807 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6808 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6809 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
|
6810 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
|
6811 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6812 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
|
6813 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6814 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6815 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6816 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6817 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
|
6818 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6819 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
|
6820 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6821 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6822 int beta; |
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 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6825 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6826 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6827 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 continue; |
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 |
3316 | 6831 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
|
6832 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
|
6833 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
|
6834 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6835 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6836 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
|
6837 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
|
6838 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6839 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6840 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6841 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6842 |
4001 | 6843 if( FFABS( p0 - q0 ) < alpha && |
6844 FFABS( p1 - p0 ) < beta && | |
6845 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6847 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6848 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6849 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6850 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
|
6851 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6852 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6853 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6854 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6855 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6856 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6857 |
4001 | 6858 if( FFABS( p0 - q0 ) < alpha && |
6859 FFABS( p1 - p0 ) < beta && | |
6860 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6861 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6862 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
|
6863 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
|
6864 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
|
6865 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6866 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6867 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6868 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6869 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6870 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
|
6871 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
|
6872 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
|
6873 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
|
6874 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
|
6875 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
|
6876 |
2633 | 6877 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
|
6878 int8_t tc[4]; |
2633 | 6879 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
|
6880 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6881 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6882 } else { | |
6883 /* 16px edge length, see filter_mb_edgev */ | |
6884 for( d = 0; d < 16; d++ ) { | |
1898 | 6885 const int p0 = pix[-1*pix_next]; |
6886 const int p1 = pix[-2*pix_next]; | |
6887 const int p2 = pix[-3*pix_next]; | |
6888 const int q0 = pix[0]; | |
6889 const int q1 = pix[1*pix_next]; | |
6890 const int q2 = pix[2*pix_next]; | |
6891 | |
4001 | 6892 if( FFABS( p0 - q0 ) < alpha && |
6893 FFABS( p1 - p0 ) < beta && | |
6894 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6895 |
6896 const int p3 = pix[-4*pix_next]; | |
6897 const int q3 = pix[ 3*pix_next]; | |
6898 | |
4001 | 6899 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6900 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6901 /* p0', p1', p2' */ |
6902 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6903 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6904 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6905 } else { | |
6906 /* p0' */ | |
6907 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6908 } | |
4001 | 6909 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6910 /* q0', q1', q2' */ |
6911 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6912 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6913 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6914 } else { | |
6915 /* q0' */ | |
6916 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6917 } | |
6918 }else{ | |
6919 /* p0', q0' */ | |
6920 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6921 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6922 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6923 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
|
6924 } |
1898 | 6925 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
|
6926 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6927 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6928 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6929 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6930 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6931 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6932 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
|
6933 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
|
6934 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
|
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 : 0; |
2633 | 6940 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6941 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6942 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
|
6943 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6944 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6945 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6946 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
|
6947 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6948 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6949 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6950 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6951 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
|
6952 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
|
6953 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6954 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6955 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6956 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6957 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6958 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6959 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6960 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6961 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6962 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6963 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6964 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6965 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6966 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6967 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6968 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 6969 qp_thresh = 15 - h->slice_alpha_c0_offset; |
6970 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
6971 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
6972 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6973 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6974 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6975 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6976 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6977 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6978 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6979 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6980 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6981 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6982 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6983 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6984 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6985 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6986 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6987 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6988 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6989 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6990 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6991 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6992 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6993 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6994 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6995 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6996 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6997 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6998 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6999 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7000 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7001 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7002 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7003 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7004 int edges; |
7005 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7006 edges = 4; | |
7007 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7008 } else { | |
7009 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7010 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7011 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7012 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7013 ? 3 : 0; | |
7014 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7015 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7016 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7017 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7018 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7019 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7020 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7021 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7022 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7023 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7024 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7025 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 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
|
7027 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7028 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
|
7029 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
|
7030 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7031 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7032 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7033 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7034 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7035 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7036 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7037 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7038 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7039 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7040 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7041 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7043 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7045 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7046 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7047 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7048 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7049 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7050 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7051 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7052 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7053 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7054 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
|
7055 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
|
7056 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7057 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7058 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
|
7059 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
|
7060 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7061 /* 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
|
7062 * 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
|
7063 * frame numbers, not indices. */ |
3316 | 7064 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7065 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
|
7066 |
3101 | 7067 //for sufficiently low qp, filtering wouldn't do anything |
7068 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7069 if(!FRAME_MBAFF){ |
3101 | 7070 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7071 int qp = s->current_picture.qscale_table[mb_xy]; | |
7072 if(qp <= qp_thresh | |
7073 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7074 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7075 return; | |
7076 } | |
7077 } | |
7078 | |
3316 | 7079 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7080 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7081 && 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
|
7082 // and current and left pair do not have the same interlaced type |
3316 | 7083 && (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
|
7084 // 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
|
7085 && (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
|
7086 /* 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
|
7087 * 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
|
7088 */ |
3316 | 7089 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7090 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
|
7091 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7092 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7093 int chroma_qp[2]; |
3316 | 7094 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
|
7095 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7096 first_vertical_edge_done = 1; |
3316 | 7097 |
7098 if( IS_INTRA(mb_type) ) | |
7099 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7100 else { | |
7101 for( i = 0; i < 8; i++ ) { | |
7102 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7103 | |
7104 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7105 bS[i] = 4; | |
7106 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7107 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7108 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7109 bS[i] = 2; | |
7110 else | |
7111 bS[i] = 1; | |
7112 } | |
7113 } | |
7114 | |
7115 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7116 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7117 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7118 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7119 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7120 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7121 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7122 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7123 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7124 | |
7125 /* Filter edge */ | |
7126 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); | |
7127 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7128 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7129 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7130 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
|
7131 } |
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
|
7132 /* 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
|
7133 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
|
7134 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7135 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7136 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7137 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7138 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7139 | |
3101 | 7140 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7141 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7142 // how often to recheck mv-based bS when iterating between edges |
7143 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7144 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7145 // how often to recheck mv-based bS when iterating along each edge | |
7146 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7147 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7148 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7149 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7150 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7151 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7152 |
2454 | 7153 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
|
7154 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
|
7155 |
3316 | 7156 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7157 && !IS_INTERLACED(mb_type) | |
7158 && IS_INTERLACED(mbm_type) | |
7159 ) { | |
7160 // This is a special case in the norm where the filtering must | |
7161 // be done twice (one each of the field) even if we are in a | |
7162 // frame macroblock. | |
7163 // | |
7164 static const int nnz_idx[4] = {4,5,6,3}; | |
7165 unsigned int tmp_linesize = 2 * linesize; | |
7166 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7167 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7168 int qp, chroma_qp; | |
7169 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7170 int16_t bS[4]; |
3316 | 7171 |
7172 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7173 if( IS_INTRA(mb_type) || | |
7174 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7175 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7176 } else { | |
7177 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7178 for( i = 0; i < 4; i++ ) { | |
7179 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7180 mbn_nnz[nnz_idx[i]] != 0 ) | |
7181 bS[i] = 2; | |
7182 else | |
7183 bS[i] = 1; | |
7184 } | |
7185 } | |
7186 // Do not use s->qscale as luma quantizer because it has not the same | |
7187 // value in IPCM macroblocks. | |
7188 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7189 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); | |
7190 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7191 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7192 chroma_qp = ( h->chroma_qp + | |
7193 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7194 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7195 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7196 } | |
7197 | |
7198 start = 1; | |
7199 } | |
7200 | |
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
|
7201 /* Calculate bS */ |
2924 | 7202 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7203 /* mbn_xy: neighbor macroblock */ |
2924 | 7204 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7205 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7206 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
|
7207 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
|
7208 |
2924 | 7209 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7210 continue; |
7211 | |
2924 | 7212 if( IS_INTRA(mb_type) || |
7213 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7214 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7215 if (edge == 0) { |
2924 | 7216 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7217 || ((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
|
7218 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7219 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7220 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7221 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7222 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7223 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7224 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7225 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7226 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
|
7227 } else { |
2924 | 7228 int i, l; |
7229 int mv_done; | |
7230 | |
7231 if( edge & mask_edge ) { | |
7232 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7233 mv_done = 1; | |
7234 } | |
3316 | 7235 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7236 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7237 mv_done = 1; | |
7238 } | |
2924 | 7239 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7240 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7241 int bn_idx= b_idx - (dir ? 8:1); | |
7242 int v = 0; | |
7243 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7244 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7245 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7246 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7247 } |
7248 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7249 mv_done = 1; | |
7250 } | |
7251 else | |
7252 mv_done = 0; | |
7253 | |
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
|
7254 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
|
7255 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
|
7256 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
|
7257 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
|
7258 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
|
7259 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7260 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7261 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
|
7262 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
|
7263 } |
2924 | 7264 else if(!mv_done) |
2523 | 7265 { |
7266 bS[i] = 0; | |
7267 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
|
7268 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7269 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7270 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7271 bS[i] = 1; |
7272 break; | |
7273 } | |
7274 } | |
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
|
7275 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7276 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7277 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7278 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
|
7279 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
|
7280 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7281 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7282 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7283 // 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
|
7284 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7285 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
|
7286 //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
|
7287 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
|
7288 { 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
|
7289 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
|
7290 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7291 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
|
7292 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
|
7293 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
|
7294 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
|
7295 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
|
7296 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7297 } 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
|
7298 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7299 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
|
7300 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
|
7301 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
|
7302 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
|
7303 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
|
7304 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7305 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7306 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7307 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7308 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7309 |
1168 | 7310 static int decode_slice(H264Context *h){ |
7311 MpegEncContext * const s = &h->s; | |
7312 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7313 | |
7314 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
|
7315 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7316 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
|
7317 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
|
7318 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7319 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7320 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
|
7321 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7322 /* 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
|
7323 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
|
7324 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
|
7325 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7326 ( 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
|
7327 /* calculate pre-state */ |
2755 | 7328 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
|
7329 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
|
7330 if( h->slice_type == I_TYPE ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7331 pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7332 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7333 pre = clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7334 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7335 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7336 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
|
7337 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7338 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7339 } |
7340 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7341 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7342 //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
|
7343 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
|
7344 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
|
7345 //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
|
7346 |
2163 | 7347 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
|
7348 |
3316 | 7349 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
|
7350 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
|
7351 |
2163 | 7352 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
|
7353 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7354 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
|
7355 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
|
7356 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7357 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
|
7358 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7359 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
|
7360 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
|
7361 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
|
7362 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
|
7363 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7364 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7365 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
|
7366 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
|
7367 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7368 ++s->mb_y; |
3316 | 7369 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7370 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7371 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7372 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7373 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7374 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7375 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
|
7376 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
|
7377 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
|
7378 } |
1168 | 7379 } |
1908
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 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7382 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7383 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
|
7384 |
2163 | 7385 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
|
7386 |
3316 | 7387 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
|
7388 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
|
7389 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
|
7390 |
2163 | 7391 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
|
7392 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7395 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
|
7396 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
|
7397 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
|
7398 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7399 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
|
7400 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7401 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7402 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
|
7403 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
|
7404 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
|
7405 ++s->mb_y; |
3316 | 7406 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7407 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7408 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7409 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
|
7410 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
|
7411 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7412 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
|
7413 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
|
7414 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7415 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
|
7416 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7417 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7418 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7419 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
|
7420 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7421 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7422 } |
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(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7425 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
|
7426 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7427 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); |
7428 | |
7429 return 0; | |
7430 }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
|
7431 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 | 7432 |
7433 return -1; | |
7434 } | |
7435 } | |
7436 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7437 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7438 |
1168 | 7439 #if 0 |
7440 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7441 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7442 int ret= decode_mb(h); | |
2967 | 7443 |
1168 | 7444 hl_decode_mb(h); |
7445 | |
7446 if(ret<0){ | |
3177 | 7447 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7448 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); |
7449 | |
7450 return -1; | |
7451 } | |
2967 | 7452 |
1168 | 7453 if(++s->mb_x >= s->mb_width){ |
7454 s->mb_x=0; | |
7455 if(++s->mb_y >= s->mb_height){ | |
7456 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7457 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); | |
7458 | |
7459 return 0; | |
7460 }else{ | |
7461 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); | |
7462 | |
7463 return -1; | |
7464 } | |
7465 } | |
7466 } | |
2967 | 7467 |
1168 | 7468 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7469 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7470 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); | |
7471 | |
7472 return 0; | |
7473 }else{ | |
7474 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); | |
7475 | |
7476 return -1; | |
7477 } | |
7478 } | |
7479 } | |
7480 s->mb_x=0; | |
7481 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7482 } | |
7483 #endif | |
7484 return -1; //not reached | |
7485 } | |
7486 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7487 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
|
7488 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7489 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7490 int e, build, i; |
2967 | 7491 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7492 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7493 return -1; |
2967 | 7494 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7495 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
|
7496 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
|
7497 } |
2967 | 7498 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7499 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7500 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
|
7501 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7502 h->x264_build= build; |
2967 | 7503 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7504 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
|
7505 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
|
7506 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7507 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7508 skip_bits(&s->gb, 8); |
2967 | 7509 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7510 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7511 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7512 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7513 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7514 MpegEncContext * const s = &h->s; |
2967 | 7515 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7516 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
|
7517 int size, type; |
2967 | 7518 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7519 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7520 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7521 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7522 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7523 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7524 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7525 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7526 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7527 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7528 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7529 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7530 case 5: |
3318 | 7531 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
|
7532 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7533 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7534 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7535 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7536 } |
2967 | 7537 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7538 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7539 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7540 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7541 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7542 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7543 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7544 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7545 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
|
7546 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7547 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7548 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
|
7549 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
|
7550 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
|
7551 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
|
7552 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
|
7553 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
|
7554 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
|
7555 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7556 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
|
7557 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
|
7558 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
|
7559 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
|
7560 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7561 |
1168 | 7562 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7563 MpegEncContext * const s = &h->s; | |
7564 int aspect_ratio_info_present_flag, aspect_ratio_idc; | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7565 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7566 |
7567 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7568 |
1168 | 7569 if( aspect_ratio_info_present_flag ) { |
7570 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7571 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7572 sps->sar.num= get_bits(&s->gb, 16); |
7573 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
|
7574 }else if(aspect_ratio_idc < 14){ |
1548 | 7575 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7576 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7577 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7578 return -1; |
7579 } | |
7580 }else{ | |
2967 | 7581 sps->sar.num= |
1548 | 7582 sps->sar.den= 0; |
1168 | 7583 } |
7584 // 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
|
7585 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7586 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
|
7587 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
|
7588 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7589 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7590 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
|
7591 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
|
7592 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
|
7593 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
|
7594 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
|
7595 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
|
7596 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
|
7597 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7598 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7599 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7600 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
|
7601 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
|
7602 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
|
7603 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7604 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7605 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
|
7606 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
|
7607 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
|
7608 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
|
7609 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
|
7610 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7611 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7612 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
|
7613 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
|
7614 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7615 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
|
7616 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
|
7617 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7618 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
|
7619 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
|
7620 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
|
7621 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7622 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
|
7623 if(sps->bitstream_restriction_flag){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7624 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
|
7625 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
|
7626 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
|
7627 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
|
7628 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7629 sps->num_reorder_frames = get_ue_golomb(&s->gb); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7630 get_ue_golomb(&s->gb); /* max_dec_frame_buffering */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7631 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7632 |
1168 | 7633 return 0; |
7634 } | |
7635 | |
3004 | 7636 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7637 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7638 MpegEncContext * const s = &h->s; |
7639 int i, last = 8, next = 8; | |
7640 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7641 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7642 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7643 else |
7644 for(i=0;i<size;i++){ | |
7645 if(next) | |
7646 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7647 if(!i && !next){ /* matrix not written, we use the preset one */ |
7648 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7649 break; |
7650 } | |
7651 last = factors[scan[i]] = next ? next : last; | |
7652 } | |
7653 } | |
7654 | |
7655 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7656 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7657 MpegEncContext * const s = &h->s; | |
7658 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7659 const uint8_t *fallback[4] = { | |
7660 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7661 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7662 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7663 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7664 }; | |
7665 if(get_bits1(&s->gb)){ | |
7666 sps->scaling_matrix_present |= is_sps; | |
3004 | 7667 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7668 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7669 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7670 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7671 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7672 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7673 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7674 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7675 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7676 } |
7677 } else if(fallback_sps) { | |
7678 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7679 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7680 } | |
7681 } | |
7682 | |
1168 | 7683 static inline int decode_seq_parameter_set(H264Context *h){ |
7684 MpegEncContext * const s = &h->s; | |
1371 | 7685 int profile_idc, level_idc; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7686 unsigned int sps_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7687 int i; |
1168 | 7688 SPS *sps; |
2967 | 7689 |
1168 | 7690 profile_idc= get_bits(&s->gb, 8); |
1371 | 7691 get_bits1(&s->gb); //constraint_set0_flag |
7692 get_bits1(&s->gb); //constraint_set1_flag | |
7693 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7694 get_bits1(&s->gb); //constraint_set3_flag |
7695 get_bits(&s->gb, 4); // reserved | |
1168 | 7696 level_idc= get_bits(&s->gb, 8); |
7697 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7698 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7699 if (sps_id >= MAX_SPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7700 // 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
|
7701 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
|
7702 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7703 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7704 |
1168 | 7705 sps= &h->sps_buffer[ sps_id ]; |
7706 sps->profile_idc= profile_idc; | |
7707 sps->level_idc= level_idc; | |
2312 | 7708 |
2755 | 7709 if(sps->profile_idc >= 100){ //high profile |
7710 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7711 get_bits1(&s->gb); //residual_color_transform_flag | |
7712 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7713 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7714 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7715 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7716 }else | |
7717 sps->scaling_matrix_present = 0; | |
2755 | 7718 |
1168 | 7719 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7720 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7721 |
1168 | 7722 if(sps->poc_type == 0){ //FIXME #define |
7723 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7724 } else if(sps->poc_type == 1){//FIXME #define | |
7725 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7726 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7727 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
7728 sps->poc_cycle_length= get_ue_golomb(&s->gb); | |
2967 | 7729 |
1168 | 7730 for(i=0; i<sps->poc_cycle_length; i++) |
7731 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
7732 } | |
7733 if(sps->poc_type > 2){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7734 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7735 return -1; |
7736 } | |
7737 | |
7738 sps->ref_frame_count= get_ue_golomb(&s->gb); | |
2254
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
7739 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){ |
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
7740 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
|
7741 } |
1371 | 7742 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
1168 | 7743 sps->mb_width= get_ue_golomb(&s->gb) + 1; |
7744 sps->mb_height= get_ue_golomb(&s->gb) + 1; | |
2967 | 7745 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 || |
2422 | 7746 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)) |
7747 return -1; | |
7748 | |
1168 | 7749 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7750 if(!sps->frame_mbs_only_flag) | |
7751 sps->mb_aff= get_bits1(&s->gb); | |
7752 else | |
7753 sps->mb_aff= 0; | |
7754 | |
7755 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7756 | |
3316 | 7757 #ifndef ALLOW_INTERLACE |
7758 if(sps->mb_aff) | |
3954 | 7759 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7760 #endif |
7761 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7762 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7763 | |
1371 | 7764 sps->crop= get_bits1(&s->gb); |
7765 if(sps->crop){ | |
7766 sps->crop_left = get_ue_golomb(&s->gb); | |
7767 sps->crop_right = get_ue_golomb(&s->gb); | |
7768 sps->crop_top = get_ue_golomb(&s->gb); | |
7769 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7770 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
|
7771 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7772 } |
7773 }else{ | |
2967 | 7774 sps->crop_left = |
7775 sps->crop_right = | |
7776 sps->crop_top = | |
1371 | 7777 sps->crop_bottom= 0; |
7778 } | |
7779 | |
1168 | 7780 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7781 if( sps->vui_parameters_present_flag ) | |
7782 decode_vui_parameters(h, sps); | |
2967 | 7783 |
1168 | 7784 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
|
7785 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 | 7786 sps_id, sps->profile_idc, sps->level_idc, |
7787 sps->poc_type, | |
7788 sps->ref_frame_count, | |
7789 sps->mb_width, sps->mb_height, | |
7790 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7791 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7792 sps->crop_left, sps->crop_right, |
7793 sps->crop_top, sps->crop_bottom, | |
1168 | 7794 sps->vui_parameters_present_flag ? "VUI" : "" |
7795 ); | |
7796 } | |
7797 return 0; | |
7798 } | |
7799 | |
2755 | 7800 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7801 MpegEncContext * const s = &h->s; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7802 unsigned int pps_id= get_ue_golomb(&s->gb); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7803 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7804 |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7805 if(pps_id>=MAX_PPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7806 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
|
7807 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7808 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7809 pps = &h->pps_buffer[pps_id]; |
2967 | 7810 |
1168 | 7811 pps->sps_id= get_ue_golomb(&s->gb); |
7812 pps->cabac= get_bits1(&s->gb); | |
7813 pps->pic_order_present= get_bits1(&s->gb); | |
7814 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7815 if(pps->slice_group_count > 1 ){ | |
7816 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
|
7817 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7818 switch(pps->mb_slice_group_map_type){ |
7819 case 0: | |
7820 #if 0 | |
7821 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7822 | run_length[ i ] |1 |ue(v) | | |
7823 #endif | |
7824 break; | |
7825 case 2: | |
7826 #if 0 | |
7827 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7828 |{ | | | | |
7829 | top_left_mb[ i ] |1 |ue(v) | | |
7830 | bottom_right_mb[ i ] |1 |ue(v) | | |
7831 | } | | | | |
7832 #endif | |
7833 break; | |
7834 case 3: | |
7835 case 4: | |
7836 case 5: | |
7837 #if 0 | |
7838 | slice_group_change_direction_flag |1 |u(1) | | |
7839 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7840 #endif | |
7841 break; | |
7842 case 6: | |
7843 #if 0 | |
7844 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7845 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7846 |) | | | | |
7847 | slice_group_id[ i ] |1 |u(v) | | |
7848 #endif | |
1214 | 7849 break; |
1168 | 7850 } |
7851 } | |
7852 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7853 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
7854 if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7855 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
1168 | 7856 return -1; |
7857 } | |
2967 | 7858 |
1168 | 7859 pps->weighted_pred= get_bits1(&s->gb); |
7860 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7861 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7862 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7863 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7864 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7865 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7866 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7867 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7868 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
|
7869 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7870 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7871 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7872 |
7873 if(get_bits_count(&s->gb) < bit_length){ | |
7874 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7875 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7876 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7877 } | |
2967 | 7878 |
1168 | 7879 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
|
7880 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 | 7881 pps_id, pps->sps_id, |
7882 pps->cabac ? "CABAC" : "CAVLC", | |
7883 pps->slice_group_count, | |
7884 pps->ref_count[0], pps->ref_count[1], | |
7885 pps->weighted_pred ? "weighted" : "", | |
7886 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7887 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7888 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7889 pps->redundant_pic_cnt_present ? "REDU" : "", |
7890 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7891 ); |
7892 } | |
2967 | 7893 |
1168 | 7894 return 0; |
7895 } | |
7896 | |
7897 /** | |
7898 * finds the end of the current frame in the bitstream. | |
7899 * @return the position of the first byte of the next frame, or -1 | |
7900 */ | |
2392 | 7901 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7902 int i; |
1168 | 7903 uint32_t state; |
2392 | 7904 ParseContext *pc = &(h->s.parse_context); |
1168 | 7905 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7906 // mb_addr= pc->mb_addr - 1; | |
7907 state= pc->state; | |
2392 | 7908 for(i=0; i<=buf_size; i++){ |
1168 | 7909 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7910 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7911 if(pc->frame_start_found){ |
2392 | 7912 // If there isn't one more byte in the buffer |
7913 // the test on first_mb_in_slice cannot be done yet | |
7914 // do it at next call. | |
7915 if (i >= buf_size) break; | |
7916 if (buf[i] & 0x80) { | |
7917 // first_mb_in_slice is 0, probably the first nal of a new | |
7918 // slice | |
7919 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 7920 pc->state=-1; |
2392 | 7921 pc->frame_start_found= 0; |
7922 return i-4; | |
7923 } | |
1168 | 7924 } |
2392 | 7925 pc->frame_start_found = 1; |
1168 | 7926 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7927 if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7928 if(pc->frame_start_found){ |
2967 | 7929 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7930 pc->frame_start_found= 0; |
2967 | 7931 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7932 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7933 } |
2392 | 7934 if (i<buf_size) |
7935 state= (state<<8) | buf[i]; | |
1168 | 7936 } |
2967 | 7937 |
1168 | 7938 pc->state= state; |
1219 | 7939 return END_NOT_FOUND; |
1168 | 7940 } |
7941 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
7942 #ifdef CONFIG_H264_PARSER |
1988 | 7943 static int h264_parse(AVCodecParserContext *s, |
7944 AVCodecContext *avctx, | |
2967 | 7945 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 7946 const uint8_t *buf, int buf_size) |
7947 { | |
2392 | 7948 H264Context *h = s->priv_data; |
7949 ParseContext *pc = &h->s.parse_context; | |
1988 | 7950 int next; |
2967 | 7951 |
2392 | 7952 next= find_frame_end(h, buf, buf_size); |
1988 | 7953 |
7954 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
7955 *poutbuf = NULL; | |
7956 *poutbuf_size = 0; | |
7957 return buf_size; | |
7958 } | |
7959 | |
7960 *poutbuf = (uint8_t *)buf; | |
7961 *poutbuf_size = buf_size; | |
7962 return next; | |
7963 } | |
7964 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7965 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7966 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7967 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7968 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7969 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7970 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7971 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7972 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7973 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7974 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7975 /* 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
|
7976 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7977 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
|
7978 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7979 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
|
7980 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7981 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7982 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7983 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7984 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7985 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7986 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7987 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
7988 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7989 |
1168 | 7990 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
7991 MpegEncContext * const s = &h->s; | |
7992 AVCodecContext * const avctx= s->avctx; | |
7993 int buf_index=0; | |
1322 | 7994 #if 0 |
1168 | 7995 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7996 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7997 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 7998 } |
7999 #endif | |
2392 | 8000 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8001 s->current_picture_ptr= NULL; |
1168 | 8002 for(;;){ |
8003 int consumed; | |
8004 int dst_length; | |
8005 int bit_length; | |
8006 uint8_t *ptr; | |
2227 | 8007 int i, nalsize = 0; |
2967 | 8008 |
2227 | 8009 if(h->is_avc) { |
8010 if(buf_index >= buf_size) break; | |
8011 nalsize = 0; | |
8012 for(i = 0; i < h->nal_length_size; i++) | |
8013 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
|
8014 if(nalsize <= 1 || nalsize > buf_size){ |
3126 | 8015 if(nalsize == 1){ |
8016 buf_index++; | |
8017 continue; | |
8018 }else{ | |
8019 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8020 break; | |
8021 } | |
8022 } | |
2227 | 8023 } else { |
1168 | 8024 // start code prefix search |
8025 for(; buf_index + 3 < buf_size; buf_index++){ | |
8026 // this should allways succeed in the first iteration | |
8027 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8028 break; | |
8029 } | |
2967 | 8030 |
1168 | 8031 if(buf_index+3 >= buf_size) break; |
2967 | 8032 |
1168 | 8033 buf_index+=3; |
2967 | 8034 } |
8035 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8036 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
|
8037 if (ptr==NULL || dst_length <= 0){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8038 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8039 } |
3341 | 8040 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8041 dst_length--; | |
1168 | 8042 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8043 | |
8044 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8045 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 | 8046 } |
2967 | 8047 |
2227 | 8048 if (h->is_avc && (nalsize != consumed)) |
8049 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8050 | |
1168 | 8051 buf_index += consumed; |
8052 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8053 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8054 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8055 continue; |
2967 | 8056 |
1168 | 8057 switch(h->nal_unit_type){ |
8058 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8059 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8060 case NAL_SLICE: |
8061 init_get_bits(&s->gb, ptr, bit_length); | |
8062 h->intra_gb_ptr= | |
8063 h->inter_gb_ptr= &s->gb; | |
8064 s->data_partitioning = 0; | |
2967 | 8065 |
2771 | 8066 if(decode_slice_header(h) < 0){ |
8067 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8068 break; | |
8069 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8070 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8071 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8072 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8073 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8074 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8075 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8076 decode_slice(h); |
8077 break; | |
8078 case NAL_DPA: | |
8079 init_get_bits(&s->gb, ptr, bit_length); | |
8080 h->intra_gb_ptr= | |
8081 h->inter_gb_ptr= NULL; | |
8082 s->data_partitioning = 1; | |
2967 | 8083 |
2771 | 8084 if(decode_slice_header(h) < 0){ |
8085 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8086 } | |
1168 | 8087 break; |
8088 case NAL_DPB: | |
8089 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8090 h->intra_gb_ptr= &h->intra_gb; | |
8091 break; | |
8092 case NAL_DPC: | |
8093 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8094 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8095 |
2967 | 8096 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
|
8097 && s->context_initialized |
2793 | 8098 && s->hurry_up < 5 |
8099 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8100 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8101 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8102 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8103 decode_slice(h); |
8104 break; | |
8105 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8106 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
|
8107 decode_sei(h); |
1168 | 8108 break; |
8109 case NAL_SPS: | |
8110 init_get_bits(&s->gb, ptr, bit_length); | |
8111 decode_seq_parameter_set(h); | |
2967 | 8112 |
1168 | 8113 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8114 s->low_delay=1; | |
2967 | 8115 |
2538 | 8116 if(avctx->has_b_frames < 2) |
8117 avctx->has_b_frames= !s->low_delay; | |
1168 | 8118 break; |
8119 case NAL_PPS: | |
8120 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8121 |
2755 | 8122 decode_picture_parameter_set(h, bit_length); |
1168 | 8123 |
8124 break; | |
2960 | 8125 case NAL_AUD: |
8126 case NAL_END_SEQUENCE: | |
8127 case NAL_END_STREAM: | |
8128 case NAL_FILLER_DATA: | |
8129 case NAL_SPS_EXT: | |
8130 case NAL_AUXILIARY_SLICE: | |
1168 | 8131 break; |
2979 | 8132 default: |
8133 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8134 } |
8135 } | |
8136 | |
1174 | 8137 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
|
8138 |
2971 | 8139 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
|
8140 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8141 |
1168 | 8142 h->prev_frame_num_offset= h->frame_num_offset; |
8143 h->prev_frame_num= h->frame_num; | |
8144 if(s->current_picture_ptr->reference){ | |
8145 h->prev_poc_msb= h->poc_msb; | |
8146 h->prev_poc_lsb= h->poc_lsb; | |
8147 } | |
8148 if(s->current_picture_ptr->reference) | |
8149 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8150 | |
8151 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
|
8152 |
1168 | 8153 MPV_frame_end(s); |
8154 | |
8155 return buf_index; | |
8156 } | |
8157 | |
8158 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8159 * returns the number of bytes consumed for building the current frame |
1168 | 8160 */ |
8161 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8162 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8163 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8164 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8165 |
1168 | 8166 return pos; |
8167 }else{ | |
8168 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8169 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8170 | |
8171 return pos; | |
8172 } | |
8173 } | |
8174 | |
2967 | 8175 static int decode_frame(AVCodecContext *avctx, |
1168 | 8176 void *data, int *data_size, |
8177 uint8_t *buf, int buf_size) | |
8178 { | |
8179 H264Context *h = avctx->priv_data; | |
8180 MpegEncContext *s = &h->s; | |
2967 | 8181 AVFrame *pict = data; |
1168 | 8182 int buf_index; |
2967 | 8183 |
1168 | 8184 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8185 s->flags2= avctx->flags2; |
1168 | 8186 |
8187 /* no supplementary picture */ | |
8188 if (buf_size == 0) { | |
8189 return 0; | |
8190 } | |
2967 | 8191 |
1168 | 8192 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8193 int next= find_frame_end(h, buf, buf_size); |
2967 | 8194 |
1988 | 8195 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8196 return buf_size; |
8197 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8198 } | |
8199 | |
2227 | 8200 if(h->is_avc && !h->got_avcC) { |
8201 int i, cnt, nalsize; | |
8202 unsigned char *p = avctx->extradata; | |
8203 if(avctx->extradata_size < 7) { | |
8204 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8205 return -1; | |
8206 } | |
8207 if(*p != 1) { | |
8208 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8209 return -1; | |
8210 } | |
8211 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8212 so put a fake nal_length_size = 2 while parsing them */ | |
8213 h->nal_length_size = 2; | |
8214 // Decode sps from avcC | |
8215 cnt = *(p+5) & 0x1f; // Number of sps | |
8216 p += 6; | |
8217 for (i = 0; i < cnt; i++) { | |
8218 nalsize = BE_16(p) + 2; | |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8219 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8220 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8221 return -1; | |
8222 } | |
8223 p += nalsize; | |
2967 | 8224 } |
2227 | 8225 // Decode pps from avcC |
8226 cnt = *(p++); // Number of pps | |
8227 for (i = 0; i < cnt; i++) { | |
8228 nalsize = BE_16(p) + 2; | |
8229 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
8230 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8231 return -1; | |
8232 } | |
8233 p += nalsize; | |
2967 | 8234 } |
2227 | 8235 // Now store right nal length size, that will be use to parse all other nals |
8236 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8237 // Do not reparse avcC | |
8238 h->got_avcC = 1; | |
8239 } | |
8240 | |
8241 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){ | |
2967 | 8242 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8243 return -1; |
8244 } | |
8245 | |
8246 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8247 if(buf_index < 0) |
1168 | 8248 return -1; |
8249 | |
2967 | 8250 //FIXME do something with unavailable reference frames |
8251 | |
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
|
8252 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8253 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8254 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8255 return -1; |
8256 } | |
8257 | |
2409 | 8258 { |
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
|
8259 Picture *out = s->current_picture_ptr; |
2561 | 8260 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8261 *data_size = sizeof(AVFrame); |
2561 | 8262 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8263 /* Sort B-frames into display order */ |
2409 | 8264 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
|
8265 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8266 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
|
8267 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8268 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
|
8269 && 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
|
8270 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
|
8271 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8272 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8273 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8274 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8275 while(h->delayed_pic[pics]) pics++; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8276 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
|
8277 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8278 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8279 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8280 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8281 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
|
8282 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
|
8283 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8284 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8285 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8286 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8287 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
|
8288 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
|
8289 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8290 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8291 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8292 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8293 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8294 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8295 { } | |
8296 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
|
8297 out = prev; |
2923 | 8298 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8299 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8300 ((!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
|
8301 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8302 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8303 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8304 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8305 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8306 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8307 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8308 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8309 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8310 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
|
8311 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
|
8312 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
|
8313 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8314 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8315 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8316 *data_size = 0; |
2561 | 8317 else |
8318 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8319 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
|
8320 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8321 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
|
8322 #endif |
2409 | 8323 |
2937 | 8324 if(out) |
8325 *pict= *(AVFrame*)out; | |
8326 else | |
8327 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8328 } | |
8329 | |
8330 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
|
8331 ff_print_debug_info(s, pict); |
1168 | 8332 //printf("out %d\n", (int)pict->data[0]); |
8333 #if 0 //? | |
8334 | |
8335 /* Return the Picture timestamp as the frame number */ | |
8336 /* we substract 1 because it is added on utils.c */ | |
8337 avctx->frame_number = s->picture_number - 1; | |
8338 #endif | |
8339 return get_consumed_bytes(s, buf_index, buf_size); | |
8340 } | |
8341 #if 0 | |
8342 static inline void fill_mb_avail(H264Context *h){ | |
8343 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
|
8344 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8345 |
8346 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
|
8347 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
|
8348 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
|
8349 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8350 }else{ |
8351 h->mb_avail[0]= | |
8352 h->mb_avail[1]= | |
8353 h->mb_avail[2]= 0; | |
8354 } | |
8355 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8356 h->mb_avail[4]= 1; //FIXME move out | |
8357 h->mb_avail[5]= 0; //FIXME move out | |
8358 } | |
8359 #endif | |
8360 | |
8361 #if 0 //selftest | |
8362 #define COUNT 8000 | |
8363 #define SIZE (COUNT*40) | |
8364 int main(){ | |
8365 int i; | |
8366 uint8_t temp[SIZE]; | |
8367 PutBitContext pb; | |
8368 GetBitContext gb; | |
8369 // int int_temp[10000]; | |
8370 DSPContext dsp; | |
8371 AVCodecContext avctx; | |
2967 | 8372 |
1168 | 8373 dsputil_init(&dsp, &avctx); |
8374 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8375 init_put_bits(&pb, temp, SIZE); |
1168 | 8376 printf("testing unsigned exp golomb\n"); |
8377 for(i=0; i<COUNT; i++){ | |
8378 START_TIMER | |
8379 set_ue_golomb(&pb, i); | |
8380 STOP_TIMER("set_ue_golomb"); | |
8381 } | |
8382 flush_put_bits(&pb); | |
2967 | 8383 |
1168 | 8384 init_get_bits(&gb, temp, 8*SIZE); |
8385 for(i=0; i<COUNT; i++){ | |
8386 int j, s; | |
2967 | 8387 |
1168 | 8388 s= show_bits(&gb, 24); |
2967 | 8389 |
1168 | 8390 START_TIMER |
8391 j= get_ue_golomb(&gb); | |
8392 if(j != i){ | |
8393 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8394 // return -1; | |
8395 } | |
8396 STOP_TIMER("get_ue_golomb"); | |
8397 } | |
2967 | 8398 |
8399 | |
1524 | 8400 init_put_bits(&pb, temp, SIZE); |
1168 | 8401 printf("testing signed exp golomb\n"); |
8402 for(i=0; i<COUNT; i++){ | |
8403 START_TIMER | |
8404 set_se_golomb(&pb, i - COUNT/2); | |
8405 STOP_TIMER("set_se_golomb"); | |
8406 } | |
8407 flush_put_bits(&pb); | |
2967 | 8408 |
1168 | 8409 init_get_bits(&gb, temp, 8*SIZE); |
8410 for(i=0; i<COUNT; i++){ | |
8411 int j, s; | |
2967 | 8412 |
1168 | 8413 s= show_bits(&gb, 24); |
2967 | 8414 |
1168 | 8415 START_TIMER |
8416 j= get_se_golomb(&gb); | |
8417 if(j != i - COUNT/2){ | |
8418 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8419 // return -1; | |
8420 } | |
8421 STOP_TIMER("get_se_golomb"); | |
8422 } | |
8423 | |
8424 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8425 |
1168 | 8426 DCTELEM block[16]; |
8427 uint8_t src[16], ref[16]; | |
8428 uint64_t error= 0, max_error=0; | |
8429 | |
8430 for(i=0; i<COUNT; i++){ | |
8431 int j; | |
8432 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8433 for(j=0; j<16; j++){ | |
8434 ref[j]= random()%255; | |
8435 src[j]= random()%255; | |
8436 } | |
8437 | |
8438 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8439 |
1168 | 8440 //normalize |
8441 for(j=0; j<16; j++){ | |
8442 // printf("%d ", block[j]); | |
8443 block[j]= block[j]*4; | |
8444 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8445 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8446 } | |
8447 // printf("\n"); | |
2967 | 8448 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8449 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8450 /* for(j=0; j<16; j++){ |
8451 printf("%d ", ref[j]); | |
8452 } | |
8453 printf("\n");*/ | |
2967 | 8454 |
1168 | 8455 for(j=0; j<16; j++){ |
4001 | 8456 int diff= FFABS(src[j] - ref[j]); |
2967 | 8457 |
1168 | 8458 error+= diff*diff; |
8459 max_error= FFMAX(max_error, diff); | |
8460 } | |
8461 } | |
8462 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8463 #if 0 | |
8464 printf("testing quantizer\n"); | |
8465 for(qp=0; qp<52; qp++){ | |
8466 for(i=0; i<16; i++) | |
8467 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8468 |
1168 | 8469 } |
8470 #endif | |
8471 printf("Testing NAL layer\n"); | |
2967 | 8472 |
1168 | 8473 uint8_t bitstream[COUNT]; |
8474 uint8_t nal[COUNT*2]; | |
8475 H264Context h; | |
8476 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8477 |
1168 | 8478 for(i=0; i<COUNT; i++){ |
8479 int zeros= i; | |
8480 int nal_length; | |
8481 int consumed; | |
8482 int out_length; | |
8483 uint8_t *out; | |
8484 int j; | |
2967 | 8485 |
1168 | 8486 for(j=0; j<COUNT; j++){ |
8487 bitstream[j]= (random() % 255) + 1; | |
8488 } | |
2967 | 8489 |
1168 | 8490 for(j=0; j<zeros; j++){ |
8491 int pos= random() % COUNT; | |
8492 while(bitstream[pos] == 0){ | |
8493 pos++; | |
8494 pos %= COUNT; | |
8495 } | |
8496 bitstream[pos]=0; | |
8497 } | |
2967 | 8498 |
1168 | 8499 START_TIMER |
2967 | 8500 |
1168 | 8501 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8502 if(nal_length<0){ | |
8503 printf("encoding failed\n"); | |
8504 return -1; | |
8505 } | |
2967 | 8506 |
1168 | 8507 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8508 | |
8509 STOP_TIMER("NAL") | |
2967 | 8510 |
1168 | 8511 if(out_length != COUNT){ |
8512 printf("incorrect length %d %d\n", out_length, COUNT); | |
8513 return -1; | |
8514 } | |
2967 | 8515 |
1168 | 8516 if(consumed != nal_length){ |
8517 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8518 return -1; | |
8519 } | |
2967 | 8520 |
1168 | 8521 if(memcmp(bitstream, out, COUNT)){ |
8522 printf("missmatch\n"); | |
8523 return -1; | |
8524 } | |
8525 } | |
2967 | 8526 |
1168 | 8527 printf("Testing RBSP\n"); |
2967 | 8528 |
8529 | |
1168 | 8530 return 0; |
8531 } | |
8532 #endif | |
8533 | |
8534 | |
8535 static int decode_end(AVCodecContext *avctx) | |
8536 { | |
8537 H264Context *h = avctx->priv_data; | |
8538 MpegEncContext *s = &h->s; | |
2967 | 8539 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8540 av_freep(&h->rbsp_buffer); |
1168 | 8541 free_tables(h); //FIXME cleanup init stuff perhaps |
8542 MPV_common_end(s); | |
8543 | |
8544 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8545 |
1168 | 8546 return 0; |
8547 } | |
8548 | |
8549 | |
8550 AVCodec h264_decoder = { | |
8551 "h264", | |
8552 CODEC_TYPE_VIDEO, | |
8553 CODEC_ID_H264, | |
8554 sizeof(H264Context), | |
8555 decode_init, | |
8556 NULL, | |
8557 decode_end, | |
8558 decode_frame, | |
2453 | 8559 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8560 .flush= flush_dpb, |
1168 | 8561 }; |
8562 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8563 #ifdef CONFIG_H264_PARSER |
1988 | 8564 AVCodecParser h264_parser = { |
8565 { CODEC_ID_H264 }, | |
2392 | 8566 sizeof(H264Context), |
1988 | 8567 NULL, |
8568 h264_parse, | |
8569 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8570 h264_split, |
1988 | 8571 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8572 #endif |
1988 | 8573 |
1234 | 8574 #include "svq3.c" |