Mercurial > libavcodec.hg
annotate h264.c @ 4040:9eaea06c5ba6 libavcodec
optimize sign decoding code in decode_residual()
x86 is 4% faster on P3
C sign stuff + x86 code for everything else is also faster then before (sorry forgot to test pure C)
... and if i replace the second occurance of the sign decoding in decode_residual by the asm too then everything gets slower iam starting to think that it might be best to write the whole function in asm, playing this avoid random deoptimizations game with gcc is not fun at all
author | michael |
---|---|
date | Thu, 19 Oct 2006 01:19:03 +0000 |
parents | 16697bdf4ac2 |
children | 0113ceb0f953 |
rev | line source |
---|---|
1168 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1168 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1168 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1168 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3029
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1168 | 20 * |
21 */ | |
2967 | 22 |
1168 | 23 /** |
24 * @file h264.c | |
25 * H.264 / AVC / MPEG4 part10 codec. | |
26 * @author Michael Niedermayer <michaelni@gmx.at> | |
27 */ | |
28 | |
29 #include "common.h" | |
30 #include "dsputil.h" | |
31 #include "avcodec.h" | |
32 #include "mpegvideo.h" | |
33 #include "h264data.h" | |
34 #include "golomb.h" | |
35 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
36 #include "cabac.h" |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
37 |
3284
a224d9752912
don't force asserts in release builds. 2% faster h264.
lorenm
parents:
3219
diff
changeset
|
38 //#undef NDEBUG |
1168 | 39 #include <assert.h> |
40 | |
41 #define interlaced_dct interlaced_dct_is_a_bad_name | |
42 #define mb_intra mb_intra_isnt_initalized_see_mb_type | |
43 | |
44 #define LUMA_DC_BLOCK_INDEX 25 | |
45 #define CHROMA_DC_BLOCK_INDEX 26 | |
46 | |
47 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
48 #define COEFF_TOKEN_VLC_BITS 8 | |
49 #define TOTAL_ZEROS_VLC_BITS 9 | |
50 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
51 #define RUN_VLC_BITS 3 | |
52 #define RUN7_VLC_BITS 6 | |
53 | |
54 #define MAX_SPS_COUNT 32 | |
55 #define MAX_PPS_COUNT 256 | |
56 | |
57 #define MAX_MMCO_COUNT 66 | |
58 | |
3316 | 59 /* Compiling in interlaced support reduces the speed |
60 * of progressive decoding by about 2%. */ | |
61 #define ALLOW_INTERLACE | |
62 | |
63 #ifdef ALLOW_INTERLACE | |
64 #define MB_MBAFF h->mb_mbaff | |
65 #define MB_FIELD h->mb_field_decoding_flag | |
66 #define FRAME_MBAFF h->mb_aff_frame | |
67 #else | |
68 #define MB_MBAFF 0 | |
69 #define MB_FIELD 0 | |
70 #define FRAME_MBAFF 0 | |
71 #undef IS_INTERLACED | |
72 #define IS_INTERLACED(mb_type) 0 | |
73 #endif | |
74 | |
1168 | 75 /** |
76 * Sequence parameter set | |
77 */ | |
78 typedef struct SPS{ | |
2967 | 79 |
1168 | 80 int profile_idc; |
81 int level_idc; | |
2763 | 82 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag |
1168 | 83 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 |
84 int poc_type; ///< pic_order_cnt_type | |
85 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
86 int delta_pic_order_always_zero_flag; | |
87 int offset_for_non_ref_pic; | |
88 int offset_for_top_to_bottom_field; | |
89 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
90 int ref_frame_count; ///< num_ref_frames | |
1371 | 91 int gaps_in_frame_num_allowed_flag; |
1168 | 92 int mb_width; ///< frame_width_in_mbs_minus1 + 1 |
93 int mb_height; ///< frame_height_in_mbs_minus1 + 1 | |
94 int frame_mbs_only_flag; | |
95 int mb_aff; ///<mb_adaptive_frame_field_flag | |
96 int direct_8x8_inference_flag; | |
1371 | 97 int crop; ///< frame_cropping_flag |
98 int crop_left; ///< frame_cropping_rect_left_offset | |
99 int crop_right; ///< frame_cropping_rect_right_offset | |
100 int crop_top; ///< frame_cropping_rect_top_offset | |
101 int crop_bottom; ///< frame_cropping_rect_bottom_offset | |
1168 | 102 int vui_parameters_present_flag; |
1548 | 103 AVRational sar; |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
104 int timing_info_present_flag; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
105 uint32_t num_units_in_tick; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
106 uint32_t time_scale; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
107 int fixed_frame_rate_flag; |
1168 | 108 short offset_for_ref_frame[256]; //FIXME dyn aloc? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
109 int bitstream_restriction_flag; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
110 int num_reorder_frames; |
2919 | 111 int scaling_matrix_present; |
112 uint8_t scaling_matrix4[6][16]; | |
113 uint8_t scaling_matrix8[2][64]; | |
1168 | 114 }SPS; |
115 | |
116 /** | |
117 * Picture parameter set | |
118 */ | |
119 typedef struct PPS{ | |
120 int sps_id; | |
121 int cabac; ///< entropy_coding_mode_flag | |
122 int pic_order_present; ///< pic_order_present_flag | |
123 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
124 int mb_slice_group_map_type; | |
125 int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 | |
126 int weighted_pred; ///< weighted_pred_flag | |
127 int weighted_bipred_idc; | |
128 int init_qp; ///< pic_init_qp_minus26 + 26 | |
129 int init_qs; ///< pic_init_qs_minus26 + 26 | |
130 int chroma_qp_index_offset; | |
131 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag | |
132 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
133 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
2755 | 134 int transform_8x8_mode; ///< transform_8x8_mode_flag |
2919 | 135 uint8_t scaling_matrix4[6][16]; |
136 uint8_t scaling_matrix8[2][64]; | |
1168 | 137 }PPS; |
138 | |
139 /** | |
140 * Memory management control operation opcode. | |
141 */ | |
142 typedef enum MMCOOpcode{ | |
143 MMCO_END=0, | |
144 MMCO_SHORT2UNUSED, | |
145 MMCO_LONG2UNUSED, | |
146 MMCO_SHORT2LONG, | |
147 MMCO_SET_MAX_LONG, | |
2967 | 148 MMCO_RESET, |
1168 | 149 MMCO_LONG, |
150 } MMCOOpcode; | |
151 | |
152 /** | |
153 * Memory management control operation. | |
154 */ | |
155 typedef struct MMCO{ | |
156 MMCOOpcode opcode; | |
157 int short_frame_num; | |
158 int long_index; | |
159 } MMCO; | |
160 | |
161 /** | |
162 * H264Context | |
163 */ | |
164 typedef struct H264Context{ | |
165 MpegEncContext s; | |
2967 | 166 int nal_ref_idc; |
1168 | 167 int nal_unit_type; |
2979 | 168 #define NAL_SLICE 1 |
169 #define NAL_DPA 2 | |
170 #define NAL_DPB 3 | |
171 #define NAL_DPC 4 | |
172 #define NAL_IDR_SLICE 5 | |
173 #define NAL_SEI 6 | |
174 #define NAL_SPS 7 | |
175 #define NAL_PPS 8 | |
176 #define NAL_AUD 9 | |
2960 | 177 #define NAL_END_SEQUENCE 10 |
178 #define NAL_END_STREAM 11 | |
179 #define NAL_FILLER_DATA 12 | |
180 #define NAL_SPS_EXT 13 | |
181 #define NAL_AUXILIARY_SLICE 19 | |
1168 | 182 uint8_t *rbsp_buffer; |
3066
04b924f8f5a5
warning fixes by Luca Abeni, lucabe72 ##@## email ##.## it
diego
parents:
3063
diff
changeset
|
183 unsigned int rbsp_buffer_size; |
1168 | 184 |
2227 | 185 /** |
186 * Used to parse AVC variant of h264 | |
187 */ | |
188 int is_avc; ///< this flag is != 0 if codec is avc1 | |
189 int got_avcC; ///< flag used to parse avcC data only once | |
190 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
191 | |
1168 | 192 int chroma_qp; //QPc |
193 | |
3316 | 194 int prev_mb_skipped; |
195 int next_mb_skipped; | |
1168 | 196 |
197 //prediction stuff | |
198 int chroma_pred_mode; | |
199 int intra16x16_pred_mode; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
200 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
201 int top_mb_xy; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
202 int left_mb_xy[2]; |
2967 | 203 |
1168 | 204 int8_t intra4x4_pred_mode_cache[5*8]; |
205 int8_t (*intra4x4_pred_mode)[8]; | |
206 void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp? | |
2755 | 207 void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride); |
1168 | 208 void (*pred8x8 [4+3])(uint8_t *src, int stride); |
209 void (*pred16x16[4+3])(uint8_t *src, int stride); | |
210 unsigned int topleft_samples_available; | |
211 unsigned int top_samples_available; | |
212 unsigned int topright_samples_available; | |
213 unsigned int left_samples_available; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
214 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
|
215 uint8_t left_border[2*(17+2*9)]; |
1168 | 216 |
217 /** | |
218 * non zero coeff count cache. | |
219 * is 64 if not available. | |
220 */ | |
3089 | 221 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
|
222 uint8_t (*non_zero_count)[16]; |
1168 | 223 |
224 /** | |
225 * Motion vector cache. | |
226 */ | |
3089 | 227 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); |
228 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); | |
1168 | 229 #define LIST_NOT_USED -1 //FIXME rename? |
230 #define PART_NOT_AVAILABLE -2 | |
2967 | 231 |
1168 | 232 /** |
233 * is 1 if the specific list MV&references are set to 0,0,-2. | |
234 */ | |
235 int mv_cache_clean[2]; | |
236 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
237 /** |
2755 | 238 * number of neighbors (top and/or left) that used 8x8 dct |
239 */ | |
240 int neighbor_transform_size; | |
241 | |
242 /** | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
243 * 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
|
244 * 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
|
245 */ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
246 int block_offset[2*(16+8)]; |
2967 | 247 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
248 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
|
249 uint32_t *mb2b8_xy; |
2395 | 250 int b_stride; //FIXME use s->b4_stride |
1168 | 251 int b8_stride; |
252 | |
3316 | 253 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff |
254 int mb_uvlinesize; | |
255 | |
256 int emu_edge_width; | |
257 int emu_edge_height; | |
258 | |
1234 | 259 int halfpel_flag; |
260 int thirdpel_flag; | |
261 | |
1319 | 262 int unknown_svq3_flag; |
263 int next_slice_index; | |
264 | |
1168 | 265 SPS sps_buffer[MAX_SPS_COUNT]; |
266 SPS sps; ///< current sps | |
2967 | 267 |
1168 | 268 PPS pps_buffer[MAX_PPS_COUNT]; |
269 /** | |
270 * current pps | |
271 */ | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
272 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? |
1168 | 273 |
2919 | 274 uint32_t dequant4_buffer[6][52][16]; |
275 uint32_t dequant8_buffer[2][52][64]; | |
276 uint32_t (*dequant4_coeff[6])[16]; | |
277 uint32_t (*dequant8_coeff[2])[64]; | |
278 int dequant_coeff_pps; ///< reinit tables when pps changes | |
2755 | 279 |
1168 | 280 int slice_num; |
281 uint8_t *slice_table_base; | |
3316 | 282 uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
1168 | 283 int slice_type; |
284 int slice_type_fixed; | |
2967 | 285 |
1168 | 286 //interlacing specific flags |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
287 int mb_aff_frame; |
1168 | 288 int mb_field_decoding_flag; |
3316 | 289 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag |
2967 | 290 |
1168 | 291 int sub_mb_type[4]; |
2967 | 292 |
1168 | 293 //POC stuff |
294 int poc_lsb; | |
295 int poc_msb; | |
296 int delta_poc_bottom; | |
297 int delta_poc[2]; | |
298 int frame_num; | |
299 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
300 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
301 int frame_num_offset; ///< for POC type 2 | |
302 int prev_frame_num_offset; ///< for POC type 2 | |
303 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
304 | |
305 /** | |
306 * frame_num for frames or 2*frame_num for field pics. | |
307 */ | |
308 int curr_pic_num; | |
2967 | 309 |
1168 | 310 /** |
311 * max_frame_num or 2*max_frame_num for field pics. | |
312 */ | |
313 int max_pic_num; | |
314 | |
315 //Weighted pred stuff | |
2415 | 316 int use_weight; |
317 int use_weight_chroma; | |
1168 | 318 int luma_log2_weight_denom; |
319 int chroma_log2_weight_denom; | |
3316 | 320 int luma_weight[2][48]; |
321 int luma_offset[2][48]; | |
322 int chroma_weight[2][48][2]; | |
323 int chroma_offset[2][48][2]; | |
324 int implicit_weight[48][48]; | |
2967 | 325 |
1168 | 326 //deblock |
2967 | 327 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
|
328 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
|
329 int slice_beta_offset; |
2967 | 330 |
1168 | 331 int redundant_pic_count; |
2967 | 332 |
1168 | 333 int direct_spatial_mv_pred; |
2396 | 334 int dist_scale_factor[16]; |
3316 | 335 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
|
336 int map_col_to_list0[2][16]; |
3316 | 337 int map_col_to_list0_field[2][32]; |
1168 | 338 |
339 /** | |
340 * num_ref_idx_l0/1_active_minus1 + 1 | |
341 */ | |
3316 | 342 int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
2582 | 343 Picture *short_ref[32]; |
344 Picture *long_ref[32]; | |
1168 | 345 Picture default_ref_list[2][32]; |
3316 | 346 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs |
2409 | 347 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
|
348 Picture *delayed_output_pic; |
2967 | 349 |
1168 | 350 /** |
351 * memory management control operations buffer. | |
352 */ | |
353 MMCO mmco[MAX_MMCO_COUNT]; | |
354 int mmco_index; | |
2967 | 355 |
1168 | 356 int long_ref_count; ///< number of actual long term references |
357 int short_ref_count; ///< number of actual short term references | |
2967 | 358 |
1168 | 359 //data partitioning |
360 GetBitContext intra_gb; | |
361 GetBitContext inter_gb; | |
362 GetBitContext *intra_gb_ptr; | |
363 GetBitContext *inter_gb_ptr; | |
2967 | 364 |
3089 | 365 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
|
366 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
367 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
368 * Cabac |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
369 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
370 CABACContext cabac; |
2755 | 371 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
|
372 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
|
373 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
374 /* 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
|
375 uint16_t *cbp_table; |
3651 | 376 int cbp; |
2314 | 377 int top_cbp; |
378 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
|
379 /* 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
|
380 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
|
381 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
|
382 int16_t (*mvd_table[2])[2]; |
3089 | 383 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); |
2396 | 384 uint8_t *direct_table; |
385 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
|
386 |
2748
135aa7d0bd17
avoid one transpose (730->680 dezicycles on duron)
michael
parents:
2717
diff
changeset
|
387 uint8_t zigzag_scan[16]; |
3174 | 388 uint8_t zigzag_scan8x8[64]; |
389 uint8_t zigzag_scan8x8_cavlc[64]; | |
3316 | 390 uint8_t field_scan[16]; |
391 uint8_t field_scan8x8[64]; | |
392 uint8_t field_scan8x8_cavlc[64]; | |
2763 | 393 const uint8_t *zigzag_scan_q0; |
3174 | 394 const uint8_t *zigzag_scan8x8_q0; |
395 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
3316 | 396 const uint8_t *field_scan_q0; |
397 const uint8_t *field_scan8x8_q0; | |
398 const uint8_t *field_scan8x8_cavlc_q0; | |
2967 | 399 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
400 int x264_build; |
1168 | 401 }H264Context; |
402 | |
403 static VLC coeff_token_vlc[4]; | |
404 static VLC chroma_dc_coeff_token_vlc; | |
405 | |
406 static VLC total_zeros_vlc[15]; | |
407 static VLC chroma_dc_total_zeros_vlc[3]; | |
408 | |
409 static VLC run_vlc[6]; | |
410 static VLC run7_vlc; | |
411 | |
1234 | 412 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
413 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
|
414 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
|
415 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 | 416 |
3028 | 417 static always_inline uint32_t pack16to32(int a, int b){ |
1269 | 418 #ifdef WORDS_BIGENDIAN |
419 return (b&0xFFFF) + (a<<16); | |
420 #else | |
421 return (a&0xFFFF) + (b<<16); | |
422 #endif | |
423 } | |
424 | |
1168 | 425 /** |
426 * fill a rectangle. | |
2392 | 427 * @param h height of the rectangle, should be a constant |
428 * @param w width of the rectangle, should be a constant | |
1168 | 429 * @param size the size of val (1 or 4), should be a constant |
430 */ | |
3028 | 431 static always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 432 uint8_t *p= (uint8_t*)vp; |
1168 | 433 assert(size==1 || size==4); |
3315 | 434 assert(w<=4); |
2967 | 435 |
1168 | 436 w *= size; |
437 stride *= size; | |
2967 | 438 |
2962 | 439 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 440 assert((stride&(w-1))==0); |
3315 | 441 if(w==2){ |
442 const uint16_t v= size==4 ? val : val*0x0101; | |
443 *(uint16_t*)(p + 0*stride)= v; | |
444 if(h==1) return; | |
445 *(uint16_t*)(p + 1*stride)= v; | |
446 if(h==2) return; | |
1168 | 447 *(uint16_t*)(p + 2*stride)= |
3315 | 448 *(uint16_t*)(p + 3*stride)= v; |
449 }else if(w==4){ | |
450 const uint32_t v= size==4 ? val : val*0x01010101; | |
451 *(uint32_t*)(p + 0*stride)= v; | |
452 if(h==1) return; | |
453 *(uint32_t*)(p + 1*stride)= v; | |
454 if(h==2) return; | |
1168 | 455 *(uint32_t*)(p + 2*stride)= |
3315 | 456 *(uint32_t*)(p + 3*stride)= v; |
457 }else if(w==8){ | |
458 //gcc can't optimize 64bit math on x86_32 | |
459 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
460 const uint64_t v= val*0x0100000001ULL; | |
461 *(uint64_t*)(p + 0*stride)= v; | |
462 if(h==1) return; | |
463 *(uint64_t*)(p + 1*stride)= v; | |
464 if(h==2) return; | |
1168 | 465 *(uint64_t*)(p + 2*stride)= |
3315 | 466 *(uint64_t*)(p + 3*stride)= v; |
467 }else if(w==16){ | |
468 const uint64_t v= val*0x0100000001ULL; | |
1168 | 469 *(uint64_t*)(p + 0+0*stride)= |
470 *(uint64_t*)(p + 8+0*stride)= | |
471 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 472 *(uint64_t*)(p + 8+1*stride)= v; |
473 if(h==2) return; | |
1168 | 474 *(uint64_t*)(p + 0+2*stride)= |
475 *(uint64_t*)(p + 8+2*stride)= | |
476 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 477 *(uint64_t*)(p + 8+3*stride)= v; |
478 #else | |
479 *(uint32_t*)(p + 0+0*stride)= | |
480 *(uint32_t*)(p + 4+0*stride)= val; | |
481 if(h==1) return; | |
482 *(uint32_t*)(p + 0+1*stride)= | |
483 *(uint32_t*)(p + 4+1*stride)= val; | |
484 if(h==2) return; | |
485 *(uint32_t*)(p + 0+2*stride)= | |
486 *(uint32_t*)(p + 4+2*stride)= | |
487 *(uint32_t*)(p + 0+3*stride)= | |
488 *(uint32_t*)(p + 4+3*stride)= val; | |
489 }else if(w==16){ | |
490 *(uint32_t*)(p + 0+0*stride)= | |
491 *(uint32_t*)(p + 4+0*stride)= | |
492 *(uint32_t*)(p + 8+0*stride)= | |
493 *(uint32_t*)(p +12+0*stride)= | |
494 *(uint32_t*)(p + 0+1*stride)= | |
495 *(uint32_t*)(p + 4+1*stride)= | |
496 *(uint32_t*)(p + 8+1*stride)= | |
497 *(uint32_t*)(p +12+1*stride)= val; | |
498 if(h==2) return; | |
499 *(uint32_t*)(p + 0+2*stride)= | |
500 *(uint32_t*)(p + 4+2*stride)= | |
501 *(uint32_t*)(p + 8+2*stride)= | |
502 *(uint32_t*)(p +12+2*stride)= | |
503 *(uint32_t*)(p + 0+3*stride)= | |
504 *(uint32_t*)(p + 4+3*stride)= | |
505 *(uint32_t*)(p + 8+3*stride)= | |
506 *(uint32_t*)(p +12+3*stride)= val; | |
507 #endif | |
1168 | 508 }else |
509 assert(0); | |
3315 | 510 assert(h==4); |
1168 | 511 } |
512 | |
3028 | 513 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 514 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
|
515 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 516 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
517 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
|
518 int left_block[8]; |
1168 | 519 int i; |
520 | |
3482 | 521 //FIXME deblocking could skip the intra and nnz parts. |
522 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
|
523 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
524 |
2967 | 525 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
526 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
527 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
|
528 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
529 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
530 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
|
531 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
532 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
533 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
534 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
535 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
536 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
537 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
538 left_block[7]= 11; |
3316 | 539 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
540 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
|
541 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
|
542 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
|
543 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
|
544 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
|
545 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
|
546 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
|
547 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
|
548 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
|
549 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
|
550 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
|
551 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
552 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
553 : (!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
|
554 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
555 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
556 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
557 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
558 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
559 : (!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
|
560 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
561 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
562 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
563 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
564 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
565 : (!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
|
566 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
567 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
568 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
569 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
|
570 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
|
571 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
572 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
573 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
574 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
575 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
576 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
577 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
578 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
579 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
580 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
581 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
582 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
583 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
584 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
585 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
586 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
587 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
588 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
589 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
590 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
591 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
592 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
593 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
594 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
595 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
596 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
597 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
598 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
599 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
600 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
601 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
602 } |
1168 | 603 } |
604 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
605 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
|
606 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
|
607 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
|
608 if(for_deblock){ |
3482 | 609 topleft_type = 0; |
610 topright_type = 0; | |
2449 | 611 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
612 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
613 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 614 |
615 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
616 int list; | |
617 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
618 for(i=0; i<16; i++) | |
619 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
620 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ | |
621 if(USES_LIST(mb_type,list)){ | |
622 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
623 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 624 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 625 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
626 dst[0] = src[0]; | |
627 dst[1] = src[1]; | |
628 dst[2] = src[2]; | |
629 dst[3] = src[3]; | |
630 } | |
631 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
632 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
633 ref += h->b8_stride; | |
634 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
635 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
636 }else{ | |
637 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
638 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
639 } | |
640 } | |
641 } | |
2449 | 642 }else{ |
643 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
644 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
645 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
646 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
647 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
648 } | |
1168 | 649 |
650 if(IS_INTRA(mb_type)){ | |
2967 | 651 h->topleft_samples_available= |
652 h->top_samples_available= | |
1168 | 653 h->left_samples_available= 0xFFFF; |
654 h->topright_samples_available= 0xEEEA; | |
655 | |
656 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
657 h->topleft_samples_available= 0xB3FF; | |
658 h->top_samples_available= 0x33FF; | |
659 h->topright_samples_available= 0x26EA; | |
660 } | |
661 for(i=0; i<2; i++){ | |
662 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
663 h->topleft_samples_available&= 0xDF5F; | |
664 h->left_samples_available&= 0x5F5F; | |
665 } | |
666 } | |
2967 | 667 |
1168 | 668 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
669 h->topleft_samples_available&= 0x7FFF; | |
2967 | 670 |
1168 | 671 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
672 h->topright_samples_available&= 0xFBFF; | |
2967 | 673 |
1168 | 674 if(IS_INTRA4x4(mb_type)){ |
675 if(IS_INTRA4x4(top_type)){ | |
676 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
677 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
678 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
679 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
680 }else{ | |
681 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
682 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
|
683 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
684 else{ |
1168 | 685 pred= 2; |
686 } | |
687 h->intra4x4_pred_mode_cache[4+8*0]= | |
688 h->intra4x4_pred_mode_cache[5+8*0]= | |
689 h->intra4x4_pred_mode_cache[6+8*0]= | |
690 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
691 } | |
692 for(i=0; i<2; i++){ | |
693 if(IS_INTRA4x4(left_type[i])){ | |
694 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
695 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
696 }else{ | |
697 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
698 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
|
699 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
700 else{ |
1168 | 701 pred= 2; |
702 } | |
703 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
704 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
705 } | |
706 } | |
707 } | |
708 } | |
2967 | 709 |
710 | |
1168 | 711 /* |
2967 | 712 0 . T T. T T T T |
713 1 L . .L . . . . | |
714 2 L . .L . . . . | |
715 3 . T TL . . . . | |
716 4 L . .L . . . . | |
717 5 L . .. . . . . | |
1168 | 718 */ |
719 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
720 if(top_type){ | |
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[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
|
722 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
|
723 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
|
724 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 725 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
726 h->non_zero_count_cache[1+8*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
|
727 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 728 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
729 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
|
730 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 731 |
1168 | 732 }else{ |
2967 | 733 h->non_zero_count_cache[4+8*0]= |
1168 | 734 h->non_zero_count_cache[5+8*0]= |
735 h->non_zero_count_cache[6+8*0]= | |
736 h->non_zero_count_cache[7+8*0]= | |
2967 | 737 |
1168 | 738 h->non_zero_count_cache[1+8*0]= |
739 h->non_zero_count_cache[2+8*0]= | |
2967 | 740 |
1168 | 741 h->non_zero_count_cache[1+8*3]= |
2314 | 742 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 743 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
744 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
745 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
746 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
747 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
748 h->non_zero_count_cache[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
|
749 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
|
750 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
|
751 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
|
752 }else{ |
2967 | 753 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
754 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
755 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
|
756 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
|
757 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
758 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
759 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
760 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
|
761 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
762 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
763 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
|
764 } 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
|
765 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
|
766 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
767 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
|
768 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
769 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
770 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
|
771 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
|
772 } 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
|
773 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
|
774 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
775 h->left_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
776 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
777 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
778 h->left_cbp |= ((h->cbp_table[left_xy[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
|
779 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
780 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
|
781 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
|
782 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
783 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
784 |
1168 | 785 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
786 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 787 int list; |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
788 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
|
789 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 790 /*if(!h->mv_cache_clean[list]){ |
791 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
792 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
793 h->mv_cache_clean[list]= 1; | |
794 }*/ | |
2396 | 795 continue; |
1168 | 796 } |
797 h->mv_cache_clean[list]= 0; | |
2967 | 798 |
3212 | 799 if(USES_LIST(top_type, list)){ |
1168 | 800 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
801 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
802 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
803 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
804 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
805 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
806 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
807 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
808 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
809 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
810 }else{ | |
2967 | 811 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
812 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
813 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 814 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
815 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
816 } | |
817 | |
818 //FIXME unify cleanup or sth | |
3212 | 819 if(USES_LIST(left_type[0], list)){ |
1168 | 820 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
821 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1; | |
822 *(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]]; | |
823 *(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 | 824 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)]; |
825 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 | 826 }else{ |
827 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]= | |
828 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0; | |
829 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
830 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
831 } | |
2967 | 832 |
3212 | 833 if(USES_LIST(left_type[1], list)){ |
1168 | 834 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
835 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1; | |
836 *(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]]; | |
837 *(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 | 838 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)]; |
839 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 | 840 }else{ |
841 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]= | |
842 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0; | |
843 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
844 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
2669 | 845 assert((!left_type[0]) == (!left_type[1])); |
1168 | 846 } |
847 | |
3519 | 848 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 849 continue; |
850 | |
3212 | 851 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
|
852 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
|
853 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
|
854 *(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
|
855 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
|
856 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
857 *(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
|
858 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
|
859 } |
2967 | 860 |
3212 | 861 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
|
862 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
|
863 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
|
864 *(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
|
865 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
|
866 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
867 *(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
|
868 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
|
869 } |
2967 | 870 |
3519 | 871 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 872 continue; |
2967 | 873 |
874 h->ref_cache[list][scan8[5 ]+1] = | |
875 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
876 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 877 h->ref_cache[list][scan8[4 ]] = |
1168 | 878 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
879 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
880 *(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
|
881 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 882 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
883 *(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
|
884 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
885 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
|
886 /* XXX beurk, Load mvd */ |
3212 | 887 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
|
888 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
|
889 *(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
|
890 *(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
|
891 *(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
|
892 *(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
|
893 }else{ |
2967 | 894 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
895 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
896 *(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
|
897 *(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
|
898 } |
3212 | 899 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
|
900 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
|
901 *(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
|
902 *(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
|
903 }else{ |
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 + 0*8]= |
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 + 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
|
906 } |
3212 | 907 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
|
908 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
|
909 *(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
|
910 *(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
|
911 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
912 *(uint32_t*)h->mvd_cache [list][scan8[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
|
913 *(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
|
914 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
915 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
916 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]= |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
917 *(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
|
918 *(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
|
919 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 920 |
921 if(h->slice_type == B_TYPE){ | |
922 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
923 | |
924 if(IS_DIRECT(top_type)){ | |
925 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
926 }else if(IS_8X8(top_type)){ | |
927 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
928 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
929 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
930 }else{ | |
931 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
932 } | |
2967 | 933 |
3316 | 934 if(IS_DIRECT(left_type[0])) |
935 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
936 else if(IS_8X8(left_type[0])) | |
937 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)]; | |
938 else | |
939 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
940 | |
941 if(IS_DIRECT(left_type[1])) | |
2396 | 942 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 943 else if(IS_8X8(left_type[1])) |
944 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)]; | |
945 else | |
2396 | 946 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 947 } |
948 } | |
949 | |
950 if(FRAME_MBAFF){ | |
951 #define MAP_MVS\ | |
952 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
953 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
954 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
955 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
956 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
957 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
958 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
959 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
960 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
961 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
962 if(MB_FIELD){ | |
963 #define MAP_F2F(idx, mb_type)\ | |
964 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
965 h->ref_cache[list][idx] <<= 1;\ | |
966 h->mv_cache[list][idx][1] /= 2;\ | |
967 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 968 } |
3316 | 969 MAP_MVS |
970 #undef MAP_F2F | |
971 }else{ | |
972 #define MAP_F2F(idx, mb_type)\ | |
973 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
974 h->ref_cache[list][idx] >>= 1;\ | |
975 h->mv_cache[list][idx][1] <<= 1;\ | |
976 h->mvd_cache[list][idx][1] <<= 1;\ | |
977 } | |
978 MAP_MVS | |
979 #undef MAP_F2F | |
2396 | 980 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
981 } |
1168 | 982 } |
983 } | |
984 #endif | |
2755 | 985 |
986 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 987 } |
988 | |
989 static inline void write_back_intra_pred_mode(H264Context *h){ | |
990 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
|
991 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 992 |
993 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
994 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
995 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
996 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
997 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
998 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
999 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
1000 } | |
1001 | |
1002 /** | |
1003 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1004 */ | |
1005 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
1006 MpegEncContext * const s = &h->s; | |
1007 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
1008 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
1009 int i; | |
2967 | 1010 |
1168 | 1011 if(!(h->top_samples_available&0x8000)){ |
1012 for(i=0; i<4; i++){ | |
1013 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
1014 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1015 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 | 1016 return -1; |
1017 } else if(status){ | |
1018 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
1019 } | |
1020 } | |
1021 } | |
2967 | 1022 |
1168 | 1023 if(!(h->left_samples_available&0x8000)){ |
1024 for(i=0; i<4; i++){ | |
1025 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
1026 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1027 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 | 1028 return -1; |
1029 } else if(status){ | |
1030 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
1031 } | |
1032 } | |
1033 } | |
1034 | |
1035 return 0; | |
1036 } //FIXME cleanup like next | |
1037 | |
1038 /** | |
1039 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1040 */ | |
1041 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
1042 MpegEncContext * const s = &h->s; | |
1043 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
1044 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 1045 |
2392 | 1046 if(mode < 0 || mode > 6) { |
1047 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 | 1048 return -1; |
2392 | 1049 } |
2967 | 1050 |
1168 | 1051 if(!(h->top_samples_available&0x8000)){ |
1052 mode= top[ mode ]; | |
1053 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1054 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 | 1055 return -1; |
1056 } | |
1057 } | |
2967 | 1058 |
1168 | 1059 if(!(h->left_samples_available&0x8000)){ |
1060 mode= left[ mode ]; | |
1061 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1062 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 | 1063 return -1; |
2967 | 1064 } |
1168 | 1065 } |
1066 | |
1067 return mode; | |
1068 } | |
1069 | |
1070 /** | |
1071 * gets the predicted intra4x4 prediction mode. | |
1072 */ | |
1073 static inline int pred_intra_mode(H264Context *h, int n){ | |
1074 const int index8= scan8[n]; | |
1075 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1076 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1077 const int min= FFMIN(left, top); | |
1078 | |
1170 | 1079 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 1080 |
1081 if(min<0) return DC_PRED; | |
1082 else return min; | |
1083 } | |
1084 | |
1085 static inline void write_back_non_zero_count(H264Context *h){ | |
1086 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
|
1087 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
|
1088 |
2551
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][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
|
1090 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
|
1091 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
|
1092 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
|
1093 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
|
1094 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
|
1095 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 1096 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1097 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
|
1098 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
|
1099 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
|
1100 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1101 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
|
1102 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
|
1103 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 1104 |
1105 if(FRAME_MBAFF){ | |
1106 // store all luma nnzs, for deblocking | |
1107 int v = 0, i; | |
1108 for(i=0; i<16; i++) | |
1109 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
1110 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
1111 } | |
1168 | 1112 } |
1113 | |
1114 /** | |
1115 * gets the predicted number of non zero coefficients. | |
1116 * @param n block index | |
1117 */ | |
1118 static inline int pred_non_zero_count(H264Context *h, int n){ | |
1119 const int index8= scan8[n]; | |
1120 const int left= h->non_zero_count_cache[index8 - 1]; | |
1121 const int top = h->non_zero_count_cache[index8 - 8]; | |
1122 int i= left + top; | |
2967 | 1123 |
1168 | 1124 if(i<64) i= (i+1)>>1; |
1125 | |
1170 | 1126 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 1127 |
1128 return i&31; | |
1129 } | |
1130 | |
1169 | 1131 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
1132 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
1133 | |
3316 | 1134 /* there is no consistent mapping of mvs to neighboring locations that will |
1135 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
1136 if(FRAME_MBAFF){ | |
1137 MpegEncContext *s = &h->s; | |
3776 | 1138 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 1139 const int16_t *mv; |
1140 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
1141 *C = h->mv_cache[list][scan8[0]-2]; | |
1142 | |
1143 if(!MB_FIELD | |
1144 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
1145 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
1146 if(IS_INTERLACED(mb_types[topright_xy])){ | |
1147 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
1148 const int x4 = X4, y4 = Y4;\ | |
1149 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
1150 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
1151 return LIST_NOT_USED;\ | |
1152 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
1153 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
1154 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
1155 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
1156 | |
1157 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
1158 } | |
1159 } | |
1160 if(topright_ref == PART_NOT_AVAILABLE | |
1161 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
1162 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
1163 if(!MB_FIELD | |
1164 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
1165 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
1166 } | |
1167 if(MB_FIELD | |
1168 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
1169 && i >= scan8[0]+8){ | |
1170 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
1171 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
1172 } | |
1173 } | |
1174 #undef SET_DIAG_MV | |
1175 } | |
1176 | |
1169 | 1177 if(topright_ref != PART_NOT_AVAILABLE){ |
1178 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
1179 return topright_ref; | |
1180 }else{ | |
1170 | 1181 tprintf("topright MV not available\n"); |
1182 | |
1169 | 1183 *C= h->mv_cache[list][ i - 8 - 1 ]; |
1184 return h->ref_cache[list][ i - 8 - 1 ]; | |
1185 } | |
1186 } | |
1187 | |
1168 | 1188 /** |
1189 * gets the predicted MV. | |
1190 * @param n the block index | |
1191 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
1192 * @param mx the x component of the predicted motion vector | |
1193 * @param my the y component of the predicted motion vector | |
1194 */ | |
1195 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
1196 const int index8= scan8[n]; | |
1197 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
1198 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
1199 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
1200 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 1201 const int16_t * C; |
1202 int diagonal_ref, match_count; | |
1203 | |
1168 | 1204 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 1205 |
1168 | 1206 /* mv_cache |
2967 | 1207 B . . A T T T T |
1168 | 1208 U . . L . . , . |
1209 U . . L . . . . | |
1210 U . . L . . , . | |
1211 . . . L . . . . | |
1212 */ | |
1169 | 1213 |
1214 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
1215 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
|
1216 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 1217 if(match_count > 1){ //most common |
1218 *mx= mid_pred(A[0], B[0], C[0]); | |
1219 *my= mid_pred(A[1], B[1], C[1]); | |
1220 }else if(match_count==1){ | |
1221 if(left_ref==ref){ | |
1222 *mx= A[0]; | |
2967 | 1223 *my= A[1]; |
1169 | 1224 }else if(top_ref==ref){ |
1225 *mx= B[0]; | |
2967 | 1226 *my= B[1]; |
1169 | 1227 }else{ |
1228 *mx= C[0]; | |
2967 | 1229 *my= C[1]; |
1169 | 1230 } |
1231 }else{ | |
1232 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
1233 *mx= A[0]; | |
2967 | 1234 *my= A[1]; |
1168 | 1235 }else{ |
1236 *mx= mid_pred(A[0], B[0], C[0]); | |
1237 *my= mid_pred(A[1], B[1], C[1]); | |
1238 } | |
1169 | 1239 } |
2967 | 1240 |
1187 | 1241 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 | 1242 } |
1243 | |
1244 /** | |
1245 * gets the directionally predicted 16x8 MV. | |
1246 * @param n the block index | |
1247 * @param mx the x component of the predicted motion vector | |
1248 * @param my the y component of the predicted motion vector | |
1249 */ | |
1250 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1251 if(n==0){ | |
1252 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
1253 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
1254 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1255 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 | 1256 |
1168 | 1257 if(top_ref == ref){ |
1258 *mx= B[0]; | |
1259 *my= B[1]; | |
1260 return; | |
1261 } | |
1262 }else{ | |
1263 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
1264 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 1265 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1266 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 | 1267 |
1268 if(left_ref == ref){ | |
1269 *mx= A[0]; | |
1270 *my= A[1]; | |
1271 return; | |
1272 } | |
1273 } | |
1274 | |
1275 //RARE | |
1276 pred_motion(h, n, 4, list, ref, mx, my); | |
1277 } | |
1278 | |
1279 /** | |
1280 * gets the directionally predicted 8x16 MV. | |
1281 * @param n the block index | |
1282 * @param mx the x component of the predicted motion vector | |
1283 * @param my the y component of the predicted motion vector | |
1284 */ | |
1285 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1286 if(n==0){ | |
1287 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1288 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 1289 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1290 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 | 1291 |
1292 if(left_ref == ref){ | |
1293 *mx= A[0]; | |
1294 *my= A[1]; | |
1295 return; | |
1296 } | |
1297 }else{ | |
1169 | 1298 const int16_t * C; |
1299 int diagonal_ref; | |
1300 | |
1301 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 1302 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1303 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 | 1304 |
2967 | 1305 if(diagonal_ref == ref){ |
1168 | 1306 *mx= C[0]; |
1307 *my= C[1]; | |
1308 return; | |
1309 } | |
1310 } | |
1311 | |
1312 //RARE | |
1313 pred_motion(h, n, 2, list, ref, mx, my); | |
1314 } | |
1315 | |
1316 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1317 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1318 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1319 | |
2392 | 1320 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1321 |
1322 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1323 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1324 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 1325 |
1168 | 1326 *mx = *my = 0; |
1327 return; | |
1328 } | |
2967 | 1329 |
1168 | 1330 pred_motion(h, 0, 4, 0, 0, mx, my); |
1331 | |
1332 return; | |
1333 } | |
1334 | |
2396 | 1335 static inline void direct_dist_scale_factor(H264Context * const h){ |
1336 const int poc = h->s.current_picture_ptr->poc; | |
1337 const int poc1 = h->ref_list[1][0].poc; | |
1338 int i; | |
1339 for(i=0; i<h->ref_count[0]; i++){ | |
1340 int poc0 = h->ref_list[0][i].poc; | |
1341 int td = clip(poc1 - poc0, -128, 127); | |
1342 if(td == 0 /* FIXME || pic0 is a long-term ref */){ | |
1343 h->dist_scale_factor[i] = 256; | |
1344 }else{ | |
1345 int tb = clip(poc - poc0, -128, 127); | |
4001 | 1346 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2396 | 1347 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023); |
1348 } | |
1349 } | |
3316 | 1350 if(FRAME_MBAFF){ |
1351 for(i=0; i<h->ref_count[0]; i++){ | |
1352 h->dist_scale_factor_field[2*i] = | |
1353 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
1354 } | |
1355 } | |
2396 | 1356 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1357 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
|
1358 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1359 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
|
1360 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
|
1361 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1362 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1363 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1364 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1365 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1366 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1367 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
|
1368 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
|
1369 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
|
1370 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1371 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
|
1372 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1373 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1374 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
|
1375 const int poc = ref1->ref_poc[list][i]; |
3125 | 1376 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
|
1377 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
|
1378 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
|
1379 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
|
1380 break; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1381 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1382 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1383 } |
3316 | 1384 if(FRAME_MBAFF){ |
1385 for(list=0; list<2; list++){ | |
1386 for(i=0; i<ref1->ref_count[list]; i++){ | |
1387 j = h->map_col_to_list0[list][i]; | |
1388 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1389 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1390 } | |
1391 } | |
1392 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1393 } |
2396 | 1394 |
1395 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1396 MpegEncContext * const s = &h->s; | |
1397 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1398 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1399 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1400 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1401 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
|
1402 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1403 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
|
1404 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1405 const int is_b8x8 = IS_8X8(*mb_type); |
1406 int sub_mb_type; | |
1407 int i8, i4; | |
1408 | |
3316 | 1409 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1410 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1411 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1412 * so we know exactly what block size to use */ | |
1413 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1414 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1415 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1416 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1417 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1418 }else{ | |
1419 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1420 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1421 } |
1422 if(!is_b8x8) | |
1423 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1424 if(MB_FIELD) |
1425 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1426 |
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
|
1427 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 | 1428 |
2396 | 1429 if(h->direct_spatial_mv_pred){ |
1430 int ref[2]; | |
1431 int mv[2][2]; | |
1432 int list; | |
1433 | |
3316 | 1434 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1435 | |
2396 | 1436 /* ref = min(neighbors) */ |
1437 for(list=0; list<2; list++){ | |
1438 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1439 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1440 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1441 if(refc == -2) | |
1442 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1443 ref[list] = refa; | |
1444 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1445 ref[list] = refb; | |
1446 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1447 ref[list] = refc; | |
1448 if(ref[list] < 0) | |
1449 ref[list] = -1; | |
1450 } | |
1451 | |
1452 if(ref[0] < 0 && ref[1] < 0){ | |
1453 ref[0] = ref[1] = 0; | |
1454 mv[0][0] = mv[0][1] = | |
1455 mv[1][0] = mv[1][1] = 0; | |
1456 }else{ | |
1457 for(list=0; list<2; list++){ | |
1458 if(ref[list] >= 0) | |
1459 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1460 else | |
1461 mv[list][0] = mv[list][1] = 0; | |
1462 } | |
1463 } | |
1464 | |
1465 if(ref[1] < 0){ | |
1466 *mb_type &= ~MB_TYPE_P0L1; | |
1467 sub_mb_type &= ~MB_TYPE_P0L1; | |
1468 }else if(ref[0] < 0){ | |
1469 *mb_type &= ~MB_TYPE_P0L0; | |
1470 sub_mb_type &= ~MB_TYPE_P0L0; | |
1471 } | |
1472 | |
1473 if(IS_16X16(*mb_type)){ | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1474 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
|
1475 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1476 if(!IS_INTRA(mb_type_col) |
4001 | 1477 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1478 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1479 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1480 if(ref[0] > 0) |
1481 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1482 else | |
1483 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1484 if(ref[1] > 0) | |
1485 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1486 else | |
1487 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1488 }else{ | |
1489 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1490 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1491 } | |
1492 }else{ | |
1493 for(i8=0; i8<4; i8++){ | |
1494 const int x8 = i8&1; | |
1495 const int y8 = i8>>1; | |
2967 | 1496 |
2396 | 1497 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1498 continue; | |
1499 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1500 |
2396 | 1501 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1502 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
|
1503 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
|
1504 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1505 |
2396 | 1506 /* col_zero_flag */ |
2967 | 1507 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1508 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1509 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1510 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1511 if(IS_SUB_8X8(sub_mb_type)){ |
1512 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1513 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1514 if(ref[0] == 0) |
1515 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1516 if(ref[1] == 0) | |
1517 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1518 } | |
1519 }else | |
2396 | 1520 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1521 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1522 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1523 if(ref[0] == 0) |
1524 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1525 if(ref[1] == 0) | |
1526 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1527 } | |
1528 } | |
1529 } | |
1530 } | |
1531 } | |
1532 }else{ /* direct temporal mv pred */ | |
3316 | 1533 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1534 const int *dist_scale_factor = h->dist_scale_factor; | |
1535 | |
1536 if(FRAME_MBAFF){ | |
1537 if(IS_INTERLACED(*mb_type)){ | |
1538 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1539 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1540 dist_scale_factor = h->dist_scale_factor_field; | |
1541 } | |
1542 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1543 /* FIXME assumes direct_8x8_inference == 1 */ | |
1544 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1545 int mb_types_col[2]; | |
1546 int y_shift; | |
1547 | |
1548 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1549 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1550 | (*mb_type & MB_TYPE_INTERLACED); | |
1551 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1552 | |
1553 if(IS_INTERLACED(*mb_type)){ | |
1554 /* frame to field scaling */ | |
1555 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1556 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1557 if(s->mb_y&1){ | |
1558 l1ref0 -= 2*h->b8_stride; | |
1559 l1ref1 -= 2*h->b8_stride; | |
1560 l1mv0 -= 4*h->b_stride; | |
1561 l1mv1 -= 4*h->b_stride; | |
1562 } | |
1563 y_shift = 0; | |
1564 | |
1565 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1566 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1567 && !is_b8x8) | |
1568 *mb_type |= MB_TYPE_16x8; | |
1569 else | |
1570 *mb_type |= MB_TYPE_8x8; | |
1571 }else{ | |
1572 /* field to frame scaling */ | |
1573 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1574 * but in MBAFF, top and bottom POC are equal */ | |
1575 int dy = (s->mb_y&1) ? 1 : 2; | |
1576 mb_types_col[0] = | |
1577 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1578 l1ref0 += dy*h->b8_stride; | |
1579 l1ref1 += dy*h->b8_stride; | |
1580 l1mv0 += 2*dy*h->b_stride; | |
1581 l1mv1 += 2*dy*h->b_stride; | |
1582 y_shift = 2; | |
1583 | |
1584 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1585 && !is_b8x8) | |
1586 *mb_type |= MB_TYPE_16x16; | |
1587 else | |
1588 *mb_type |= MB_TYPE_8x8; | |
1589 } | |
1590 | |
1591 for(i8=0; i8<4; i8++){ | |
1592 const int x8 = i8&1; | |
1593 const int y8 = i8>>1; | |
1594 int ref0, scale; | |
1595 const int16_t (*l1mv)[2]= l1mv0; | |
1596 | |
1597 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1598 continue; | |
1599 h->sub_mb_type[i8] = sub_mb_type; | |
1600 | |
1601 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1602 if(IS_INTRA(mb_types_col[y8])){ | |
1603 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1604 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1605 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1606 continue; | |
1607 } | |
1608 | |
1609 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1610 if(ref0 >= 0) | |
1611 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1612 else{ | |
1613 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1614 l1mv= l1mv1; | |
1615 } | |
1616 scale = dist_scale_factor[ref0]; | |
1617 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1618 | |
1619 { | |
1620 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1621 int my_col = (mv_col[1]<<y_shift)/2; | |
1622 int mx = (scale * mv_col[0] + 128) >> 8; | |
1623 int my = (scale * my_col + 128) >> 8; | |
1624 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1625 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1626 } | |
1627 } | |
1628 return; | |
1629 } | |
1630 } | |
1631 | |
1632 /* one-to-one mv scaling */ | |
1633 | |
2396 | 1634 if(IS_16X16(*mb_type)){ |
1635 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); | |
1636 if(IS_INTRA(mb_type_col)){ | |
1637 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1638 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1639 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1640 }else{ | |
3316 | 1641 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1642 : map_col_to_list0[1][l1ref1[0]]; | |
1643 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
|
1644 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1645 int mv_l0[2]; |
3316 | 1646 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1647 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1648 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1); |
1649 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4); | |
1650 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); | |
1651 } | |
1652 }else{ | |
1653 for(i8=0; i8<4; i8++){ | |
1654 const int x8 = i8&1; | |
1655 const int y8 = i8>>1; | |
3316 | 1656 int ref0, scale; |
2834 | 1657 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
|
1658 |
2396 | 1659 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1660 continue; | |
1661 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1662 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1663 if(IS_INTRA(mb_type_col)){ |
1664 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1665 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1666 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1667 continue; | |
1668 } | |
2967 | 1669 |
2396 | 1670 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
|
1671 if(ref0 >= 0) |
3316 | 1672 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
|
1673 else{ |
3316 | 1674 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
|
1675 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1676 } |
3316 | 1677 scale = dist_scale_factor[ref0]; |
2967 | 1678 |
2396 | 1679 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1680 if(IS_SUB_8X8(sub_mb_type)){ |
1681 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1682 int mx = (scale * mv_col[0] + 128) >> 8; |
1683 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1684 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1685 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1686 }else | |
2396 | 1687 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
|
1688 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1689 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1690 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1691 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1692 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1693 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1694 } | |
1695 } | |
1696 } | |
1697 } | |
1698 } | |
1699 | |
1168 | 1700 static inline void write_back_motion(H264Context *h, int mb_type){ |
1701 MpegEncContext * const s = &h->s; | |
1702 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1703 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1704 int list; | |
1705 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1706 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1707 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
|
1708 |
1168 | 1709 for(list=0; list<2; list++){ |
1710 int y; | |
3212 | 1711 if(!USES_LIST(mb_type, list)) |
2396 | 1712 continue; |
2967 | 1713 |
1168 | 1714 for(y=0; y<4; y++){ |
1715 *(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]; | |
1716 *(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]; | |
1717 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1718 if( h->pps.cabac ) { |
3927 | 1719 if(IS_SKIP(mb_type)) |
1720 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1721 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1722 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
|
1723 *(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
|
1724 *(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
|
1725 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1726 } |
3212 | 1727 |
1728 { | |
3776 | 1729 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1730 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1731 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1732 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1733 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1734 } |
1735 } | |
2967 | 1736 |
2396 | 1737 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1738 if(IS_8X8(mb_type)){ | |
3212 | 1739 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1740 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1741 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1742 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1743 } |
1744 } | |
1168 | 1745 } |
1746 | |
1747 /** | |
1748 * Decodes a network abstraction layer unit. | |
1749 * @param consumed is the number of bytes used as input | |
1750 * @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
|
1751 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1752 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1753 */ |
1754 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1755 int i, si, di; | |
1756 uint8_t *dst; | |
1757 | |
2979 | 1758 // src[0]&0x80; //forbidden bit |
1168 | 1759 h->nal_ref_idc= src[0]>>5; |
1760 h->nal_unit_type= src[0]&0x1F; | |
1761 | |
1762 src++; length--; | |
2967 | 1763 #if 0 |
1168 | 1764 for(i=0; i<length; i++) |
1765 printf("%2X ", src[i]); | |
1766 #endif | |
1767 for(i=0; i+1<length; i+=2){ | |
1768 if(src[i]) continue; | |
1769 if(i>0 && src[i-1]==0) i--; | |
1770 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1771 if(src[i+2]!=3){ | |
1772 /* startcode, so we must be past the end */ | |
1773 length=i; | |
1774 } | |
1775 break; | |
1776 } | |
1777 } | |
1778 | |
1779 if(i>=length-1){ //no escaped 0 | |
1780 *dst_length= length; | |
1781 *consumed= length+1; //+1 for the header | |
2967 | 1782 return src; |
1168 | 1783 } |
1784 | |
1785 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1786 dst= h->rbsp_buffer; | |
1787 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1788 //printf("decoding esc\n"); |
1168 | 1789 si=di=0; |
2967 | 1790 while(si<length){ |
1168 | 1791 //remove escapes (very rare 1:2^22) |
1792 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1793 if(src[si+2]==3){ //escape | |
1794 dst[di++]= 0; | |
1795 dst[di++]= 0; | |
1796 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1797 continue; |
1168 | 1798 }else //next start code |
1799 break; | |
1800 } | |
1801 | |
1802 dst[di++]= src[si++]; | |
1803 } | |
1804 | |
1805 *dst_length= di; | |
1806 *consumed= si + 1;//+1 for the header | |
1807 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1808 return dst; | |
1809 } | |
1810 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1811 #if 0 |
1168 | 1812 /** |
1813 * @param src the data which should be escaped | |
1814 * @param dst the target buffer, dst+1 == src is allowed as a special case | |
1815 * @param length the length of the src data | |
1816 * @param dst_length the length of the dst array | |
1817 * @returns length of escaped data in bytes or -1 if an error occured | |
1818 */ | |
1819 static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){ | |
1820 int i, escape_count, si, di; | |
1821 uint8_t *temp; | |
2967 | 1822 |
1168 | 1823 assert(length>=0); |
1824 assert(dst_length>0); | |
2967 | 1825 |
1168 | 1826 dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type; |
1827 | |
1828 if(length==0) return 1; | |
1829 | |
1830 escape_count= 0; | |
1831 for(i=0; i<length; i+=2){ | |
1832 if(src[i]) continue; | |
2967 | 1833 if(i>0 && src[i-1]==0) |
1168 | 1834 i--; |
1835 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1836 escape_count++; | |
1837 i+=2; | |
1838 } | |
1839 } | |
2967 | 1840 |
1841 if(escape_count==0){ | |
1168 | 1842 if(dst+1 != src) |
1843 memcpy(dst+1, src, length); | |
1844 return length + 1; | |
1845 } | |
2967 | 1846 |
1168 | 1847 if(length + escape_count + 1> dst_length) |
1848 return -1; | |
1849 | |
1850 //this should be damn rare (hopefully) | |
1851 | |
1852 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count); | |
1853 temp= h->rbsp_buffer; | |
1854 //printf("encoding esc\n"); | |
2967 | 1855 |
1168 | 1856 si= 0; |
1857 di= 0; | |
1858 while(si < length){ | |
1859 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1860 temp[di++]= 0; si++; | |
1861 temp[di++]= 0; si++; | |
2967 | 1862 temp[di++]= 3; |
1168 | 1863 temp[di++]= src[si++]; |
1864 } | |
1865 else | |
1866 temp[di++]= src[si++]; | |
1867 } | |
1868 memcpy(dst+1, temp, length+escape_count); | |
2967 | 1869 |
1168 | 1870 assert(di == length+escape_count); |
2967 | 1871 |
1168 | 1872 return di + 1; |
1873 } | |
1874 | |
1875 /** | |
1876 * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4 | |
1877 */ | |
1878 static void encode_rbsp_trailing(PutBitContext *pb){ | |
1879 int length; | |
1880 put_bits(pb, 1, 1); | |
1786 | 1881 length= (-put_bits_count(pb))&7; |
1168 | 1882 if(length) put_bits(pb, length, 0); |
1883 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1884 #endif |
1168 | 1885 |
1886 /** | |
1887 * identifies the exact end of the bitstream | |
1888 * @return the length of the trailing, or 0 if damaged | |
1889 */ | |
1890 static int decode_rbsp_trailing(uint8_t *src){ | |
1891 int v= *src; | |
1892 int r; | |
1893 | |
1170 | 1894 tprintf("rbsp trailing %X\n", v); |
1168 | 1895 |
1896 for(r=1; r<9; r++){ | |
1897 if(v&1) return r; | |
1898 v>>=1; | |
1899 } | |
1900 return 0; | |
1901 } | |
1902 | |
1903 /** | |
1904 * idct tranforms the 16 dc values and dequantize them. | |
1905 * @param qp quantization parameter | |
1906 */ | |
2919 | 1907 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1908 #define stride 16 |
1909 int i; | |
1910 int temp[16]; //FIXME check if this is a good idea | |
1911 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1912 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1913 | |
1914 //memset(block, 64, 2*256); | |
1915 //return; | |
1916 for(i=0; i<4; i++){ | |
1917 const int offset= y_offset[i]; | |
1918 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1919 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1920 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1921 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1922 | |
1923 temp[4*i+0]= z0+z3; | |
1924 temp[4*i+1]= z1+z2; | |
1925 temp[4*i+2]= z1-z2; | |
1926 temp[4*i+3]= z0-z3; | |
1927 } | |
1928 | |
1929 for(i=0; i<4; i++){ | |
1930 const int offset= x_offset[i]; | |
1931 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1932 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1933 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1934 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1935 | |
2919 | 1936 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1937 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1938 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1939 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1940 } |
1941 } | |
1942 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1943 #if 0 |
1168 | 1944 /** |
1945 * dct tranforms the 16 dc values. | |
1946 * @param qp quantization parameter ??? FIXME | |
1947 */ | |
1948 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1949 // const int qmul= dequant_coeff[qp][0]; | |
1950 int i; | |
1951 int temp[16]; //FIXME check if this is a good idea | |
1952 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1953 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1954 | |
1955 for(i=0; i<4; i++){ | |
1956 const int offset= y_offset[i]; | |
1957 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1958 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1959 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1960 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1961 | |
1962 temp[4*i+0]= z0+z3; | |
1963 temp[4*i+1]= z1+z2; | |
1964 temp[4*i+2]= z1-z2; | |
1965 temp[4*i+3]= z0-z3; | |
1966 } | |
1967 | |
1968 for(i=0; i<4; i++){ | |
1969 const int offset= x_offset[i]; | |
1970 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1971 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1972 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1973 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1974 | |
1975 block[stride*0 +offset]= (z0 + z3)>>1; | |
1976 block[stride*2 +offset]= (z1 + z2)>>1; | |
1977 block[stride*8 +offset]= (z1 - z2)>>1; | |
1978 block[stride*10+offset]= (z0 - z3)>>1; | |
1979 } | |
1980 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1981 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1982 |
1168 | 1983 #undef xStride |
1984 #undef stride | |
1985 | |
2919 | 1986 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1987 const int stride= 16*2; |
1988 const int xStride= 16; | |
1989 int a,b,c,d,e; | |
1990 | |
1991 a= block[stride*0 + xStride*0]; | |
1992 b= block[stride*0 + xStride*1]; | |
1993 c= block[stride*1 + xStride*0]; | |
1994 d= block[stride*1 + xStride*1]; | |
1995 | |
1996 e= a-b; | |
1997 a= a+b; | |
1998 b= c-d; | |
1999 c= c+d; | |
2000 | |
2919 | 2001 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
2002 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
2003 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
2004 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 2005 } |
2006 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2007 #if 0 |
1168 | 2008 static void chroma_dc_dct_c(DCTELEM *block){ |
2009 const int stride= 16*2; | |
2010 const int xStride= 16; | |
2011 int a,b,c,d,e; | |
2012 | |
2013 a= block[stride*0 + xStride*0]; | |
2014 b= block[stride*0 + xStride*1]; | |
2015 c= block[stride*1 + xStride*0]; | |
2016 d= block[stride*1 + xStride*1]; | |
2017 | |
2018 e= a-b; | |
2019 a= a+b; | |
2020 b= c-d; | |
2021 c= c+d; | |
2022 | |
2023 block[stride*0 + xStride*0]= (a+c); | |
2024 block[stride*0 + xStride*1]= (e+b); | |
2025 block[stride*1 + xStride*0]= (a-c); | |
2026 block[stride*1 + xStride*1]= (e-b); | |
2027 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2028 #endif |
1168 | 2029 |
2030 /** | |
2031 * gets the chroma qp. | |
2032 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2033 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 2034 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2035 return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 2036 } |
2037 | |
2038 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2039 #if 0 |
1168 | 2040 static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){ |
2041 int i; | |
2042 //FIXME try int temp instead of block | |
2967 | 2043 |
1168 | 2044 for(i=0; i<4; i++){ |
2045 const int d0= src1[0 + i*stride] - src2[0 + i*stride]; | |
2046 const int d1= src1[1 + i*stride] - src2[1 + i*stride]; | |
2047 const int d2= src1[2 + i*stride] - src2[2 + i*stride]; | |
2048 const int d3= src1[3 + i*stride] - src2[3 + i*stride]; | |
2049 const int z0= d0 + d3; | |
2050 const int z3= d0 - d3; | |
2051 const int z1= d1 + d2; | |
2052 const int z2= d1 - d2; | |
2967 | 2053 |
1168 | 2054 block[0 + 4*i]= z0 + z1; |
2055 block[1 + 4*i]= 2*z3 + z2; | |
2056 block[2 + 4*i]= z0 - z1; | |
2057 block[3 + 4*i]= z3 - 2*z2; | |
2967 | 2058 } |
1168 | 2059 |
2060 for(i=0; i<4; i++){ | |
2061 const int z0= block[0*4 + i] + block[3*4 + i]; | |
2062 const int z3= block[0*4 + i] - block[3*4 + i]; | |
2063 const int z1= block[1*4 + i] + block[2*4 + i]; | |
2064 const int z2= block[1*4 + i] - block[2*4 + i]; | |
2967 | 2065 |
1168 | 2066 block[0*4 + i]= z0 + z1; |
2067 block[1*4 + i]= 2*z3 + z2; | |
2068 block[2*4 + i]= z0 - z1; | |
2069 block[3*4 + i]= z3 - 2*z2; | |
2070 } | |
2071 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2072 #endif |
1168 | 2073 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2074 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close |
1168 | 2075 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away) |
2076 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){ | |
2077 int i; | |
2078 const int * const quant_table= quant_coeff[qscale]; | |
2079 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
2080 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
2081 const unsigned int threshold2= (threshold1<<1); | |
2082 int last_non_zero; | |
2083 | |
2084 if(seperate_dc){ | |
2085 if(qscale<=18){ | |
2086 //avoid overflows | |
2087 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
2088 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
2089 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
2090 | |
2091 int level= block[0]*quant_coeff[qscale+18][0]; | |
2092 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
2093 if(level>0){ | |
2094 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
2095 block[0]= level; | |
2096 }else{ | |
2097 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
2098 block[0]= -level; | |
2099 } | |
2100 // last_non_zero = i; | |
2101 }else{ | |
2102 block[0]=0; | |
2103 } | |
2104 }else{ | |
2105 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
2106 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
2107 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
2108 | |
2109 int level= block[0]*quant_table[0]; | |
2110 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
2111 if(level>0){ | |
2112 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
2113 block[0]= level; | |
2114 }else{ | |
2115 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
2116 block[0]= -level; | |
2117 } | |
2118 // last_non_zero = i; | |
2119 }else{ | |
2120 block[0]=0; | |
2121 } | |
2122 } | |
2123 last_non_zero= 0; | |
2124 i=1; | |
2125 }else{ | |
2126 last_non_zero= -1; | |
2127 i=0; | |
2128 } | |
2129 | |
2130 for(; i<16; i++){ | |
2131 const int j= scantable[i]; | |
2132 int level= block[j]*quant_table[j]; | |
2133 | |
2134 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
2135 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
2136 if(((unsigned)(level+threshold1))>threshold2){ | |
2137 if(level>0){ | |
2138 level= (bias + level)>>QUANT_SHIFT; | |
2139 block[j]= level; | |
2140 }else{ | |
2141 level= (bias - level)>>QUANT_SHIFT; | |
2142 block[j]= -level; | |
2143 } | |
2144 last_non_zero = i; | |
2145 }else{ | |
2146 block[j]=0; | |
2147 } | |
2148 } | |
2149 | |
2150 return last_non_zero; | |
2151 } | |
2152 | |
2153 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
2154 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2155 ((uint32_t*)(src+0*stride))[0]= a; | |
2156 ((uint32_t*)(src+1*stride))[0]= a; | |
2157 ((uint32_t*)(src+2*stride))[0]= a; | |
2158 ((uint32_t*)(src+3*stride))[0]= a; | |
2159 } | |
2160 | |
2161 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
2162 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
2163 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
2164 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
2165 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
2166 } | |
2167 | |
2168 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2169 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
2170 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 2171 |
2172 ((uint32_t*)(src+0*stride))[0]= | |
2173 ((uint32_t*)(src+1*stride))[0]= | |
2174 ((uint32_t*)(src+2*stride))[0]= | |
2175 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2176 } |
2177 | |
2178 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2179 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 2180 |
2181 ((uint32_t*)(src+0*stride))[0]= | |
2182 ((uint32_t*)(src+1*stride))[0]= | |
2183 ((uint32_t*)(src+2*stride))[0]= | |
2184 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2185 } |
2186 | |
2187 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2188 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 2189 |
2190 ((uint32_t*)(src+0*stride))[0]= | |
2191 ((uint32_t*)(src+1*stride))[0]= | |
2192 ((uint32_t*)(src+2*stride))[0]= | |
2193 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2194 } |
2195 | |
2196 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2197 ((uint32_t*)(src+0*stride))[0]= |
2198 ((uint32_t*)(src+1*stride))[0]= | |
2199 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 2200 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
2201 } | |
2202 | |
2203 | |
2204 #define LOAD_TOP_RIGHT_EDGE\ | |
2205 const int t4= topright[0];\ | |
2206 const int t5= topright[1];\ | |
2207 const int t6= topright[2];\ | |
2208 const int t7= topright[3];\ | |
2209 | |
2210 #define LOAD_LEFT_EDGE\ | |
2211 const int l0= src[-1+0*stride];\ | |
2212 const int l1= src[-1+1*stride];\ | |
2213 const int l2= src[-1+2*stride];\ | |
2214 const int l3= src[-1+3*stride];\ | |
2215 | |
2216 #define LOAD_TOP_EDGE\ | |
2217 const int t0= src[ 0-1*stride];\ | |
2218 const int t1= src[ 1-1*stride];\ | |
2219 const int t2= src[ 2-1*stride];\ | |
2220 const int t3= src[ 3-1*stride];\ | |
2221 | |
2222 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2223 const int lt= src[-1-1*stride]; | |
2224 LOAD_TOP_EDGE | |
2225 LOAD_LEFT_EDGE | |
2226 | |
2967 | 2227 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 2228 src[0+2*stride]= |
2967 | 2229 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 2230 src[0+1*stride]= |
2231 src[1+2*stride]= | |
2967 | 2232 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 2233 src[0+0*stride]= |
2234 src[1+1*stride]= | |
2235 src[2+2*stride]= | |
2967 | 2236 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 2237 src[1+0*stride]= |
2238 src[2+1*stride]= | |
2239 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2240 src[2+0*stride]= | |
2241 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2242 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 2243 } |
1168 | 2244 |
2245 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2246 LOAD_TOP_EDGE |
2247 LOAD_TOP_RIGHT_EDGE | |
2248 // LOAD_LEFT_EDGE | |
1168 | 2249 |
2250 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
2251 src[1+0*stride]= | |
2252 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
2253 src[2+0*stride]= | |
2254 src[1+1*stride]= | |
2255 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
2256 src[3+0*stride]= | |
2257 src[2+1*stride]= | |
2258 src[1+2*stride]= | |
2259 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
2260 src[3+1*stride]= | |
2261 src[2+2*stride]= | |
2262 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
2263 src[3+2*stride]= | |
2264 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
2265 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 2266 } |
1168 | 2267 |
2268 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2269 const int lt= src[-1-1*stride]; | |
2967 | 2270 LOAD_TOP_EDGE |
2271 LOAD_LEFT_EDGE | |
1168 | 2272 const __attribute__((unused)) int unu= l3; |
2273 | |
2274 src[0+0*stride]= | |
2275 src[1+2*stride]=(lt + t0 + 1)>>1; | |
2276 src[1+0*stride]= | |
2277 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
2278 src[2+0*stride]= | |
2279 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
2280 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
2281 src[0+1*stride]= | |
2282 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2283 src[1+1*stride]= | |
2284 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2285 src[2+1*stride]= | |
2286 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2287 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2288 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2289 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 2290 } |
1168 | 2291 |
2292 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2293 LOAD_TOP_EDGE |
2294 LOAD_TOP_RIGHT_EDGE | |
1168 | 2295 const __attribute__((unused)) int unu= t7; |
2296 | |
2297 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
2298 src[1+0*stride]= | |
2299 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
2300 src[2+0*stride]= | |
2301 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
2302 src[3+0*stride]= | |
2303 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
2304 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
2305 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2306 src[1+1*stride]= | |
2307 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2308 src[2+1*stride]= | |
2309 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
2310 src[3+1*stride]= | |
2311 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
2312 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 2313 } |
1168 | 2314 |
2315 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2316 LOAD_LEFT_EDGE |
1168 | 2317 |
2318 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
2319 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2320 src[2+0*stride]= | |
2321 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
2322 src[3+0*stride]= | |
2323 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
2324 src[2+1*stride]= | |
2325 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
2326 src[3+1*stride]= | |
2327 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
2328 src[3+2*stride]= | |
2329 src[1+3*stride]= | |
2330 src[0+3*stride]= | |
2331 src[2+2*stride]= | |
2332 src[2+3*stride]= | |
2333 src[3+3*stride]=l3; | |
1282 | 2334 } |
2967 | 2335 |
1168 | 2336 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
2337 const int lt= src[-1-1*stride]; | |
2967 | 2338 LOAD_TOP_EDGE |
2339 LOAD_LEFT_EDGE | |
1168 | 2340 const __attribute__((unused)) int unu= t3; |
2341 | |
2342 src[0+0*stride]= | |
2343 src[2+1*stride]=(lt + l0 + 1)>>1; | |
2344 src[1+0*stride]= | |
2345 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2346 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2347 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2348 src[0+1*stride]= | |
2349 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
2350 src[1+1*stride]= | |
2351 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2352 src[0+2*stride]= | |
2353 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
2354 src[1+2*stride]= | |
2355 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2356 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
2357 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 2358 } |
1168 | 2359 |
2360 static void pred16x16_vertical_c(uint8_t *src, int stride){ | |
2361 int i; | |
2362 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2363 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2364 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
2365 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 2366 |
1168 | 2367 for(i=0; i<16; i++){ |
2368 ((uint32_t*)(src+i*stride))[0]= a; | |
2369 ((uint32_t*)(src+i*stride))[1]= b; | |
2370 ((uint32_t*)(src+i*stride))[2]= c; | |
2371 ((uint32_t*)(src+i*stride))[3]= d; | |
2372 } | |
2373 } | |
2374 | |
2375 static void pred16x16_horizontal_c(uint8_t *src, int stride){ | |
2376 int i; | |
2377 | |
2378 for(i=0; i<16; i++){ | |
2379 ((uint32_t*)(src+i*stride))[0]= | |
2380 ((uint32_t*)(src+i*stride))[1]= | |
2381 ((uint32_t*)(src+i*stride))[2]= | |
2382 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
2383 } | |
2384 } | |
2385 | |
2386 static void pred16x16_dc_c(uint8_t *src, int stride){ | |
2387 int i, dc=0; | |
2388 | |
2389 for(i=0;i<16; i++){ | |
2390 dc+= src[-1+i*stride]; | |
2391 } | |
2967 | 2392 |
1168 | 2393 for(i=0;i<16; i++){ |
2394 dc+= src[i-stride]; | |
2395 } | |
2396 | |
2397 dc= 0x01010101*((dc + 16)>>5); | |
2398 | |
2399 for(i=0; i<16; i++){ | |
2400 ((uint32_t*)(src+i*stride))[0]= | |
2401 ((uint32_t*)(src+i*stride))[1]= | |
2402 ((uint32_t*)(src+i*stride))[2]= | |
2403 ((uint32_t*)(src+i*stride))[3]= dc; | |
2404 } | |
2405 } | |
2406 | |
2407 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
2408 int i, dc=0; | |
2409 | |
2410 for(i=0;i<16; i++){ | |
2411 dc+= src[-1+i*stride]; | |
2412 } | |
2967 | 2413 |
1168 | 2414 dc= 0x01010101*((dc + 8)>>4); |
2415 | |
2416 for(i=0; i<16; i++){ | |
2417 ((uint32_t*)(src+i*stride))[0]= | |
2418 ((uint32_t*)(src+i*stride))[1]= | |
2419 ((uint32_t*)(src+i*stride))[2]= | |
2420 ((uint32_t*)(src+i*stride))[3]= dc; | |
2421 } | |
2422 } | |
2423 | |
2424 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
2425 int i, dc=0; | |
2426 | |
2427 for(i=0;i<16; i++){ | |
2428 dc+= src[i-stride]; | |
2429 } | |
2430 dc= 0x01010101*((dc + 8)>>4); | |
2431 | |
2432 for(i=0; i<16; i++){ | |
2433 ((uint32_t*)(src+i*stride))[0]= | |
2434 ((uint32_t*)(src+i*stride))[1]= | |
2435 ((uint32_t*)(src+i*stride))[2]= | |
2436 ((uint32_t*)(src+i*stride))[3]= dc; | |
2437 } | |
2438 } | |
2439 | |
2440 static void pred16x16_128_dc_c(uint8_t *src, int stride){ | |
2441 int i; | |
2442 | |
2443 for(i=0; i<16; i++){ | |
2444 ((uint32_t*)(src+i*stride))[0]= | |
2445 ((uint32_t*)(src+i*stride))[1]= | |
2446 ((uint32_t*)(src+i*stride))[2]= | |
2447 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
2448 } | |
2449 } | |
2450 | |
1234 | 2451 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
|
2452 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2453 int a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2454 uint8_t *cm = cropTbl + MAX_NEG_CROP; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2455 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
|
2456 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
|
2457 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
|
2458 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
|
2459 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
|
2460 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
|
2461 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2462 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
|
2463 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
|
2464 } |
1234 | 2465 if(svq3){ |
2466 H = ( 5*(H/4) ) / 16; | |
2467 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2468 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2469 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2470 i = H; H = V; V = i; |
1234 | 2471 }else{ |
2472 H = ( 5*H+32 ) >> 6; | |
2473 V = ( 5*V+32 ) >> 6; | |
2474 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2475 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2476 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
|
2477 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
|
2478 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2479 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2480 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
|
2481 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
|
2482 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
|
2483 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
|
2484 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
|
2485 b += 4*H; |
1168 | 2486 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2487 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2488 } |
1168 | 2489 } |
2490 | |
1234 | 2491 static void pred16x16_plane_c(uint8_t *src, int stride){ |
2492 pred16x16_plane_compat_c(src, stride, 0); | |
2493 } | |
2494 | |
1168 | 2495 static void pred8x8_vertical_c(uint8_t *src, int stride){ |
2496 int i; | |
2497 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2498 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2499 |
1168 | 2500 for(i=0; i<8; i++){ |
2501 ((uint32_t*)(src+i*stride))[0]= a; | |
2502 ((uint32_t*)(src+i*stride))[1]= b; | |
2503 } | |
2504 } | |
2505 | |
2506 static void pred8x8_horizontal_c(uint8_t *src, int stride){ | |
2507 int i; | |
2508 | |
2509 for(i=0; i<8; i++){ | |
2510 ((uint32_t*)(src+i*stride))[0]= | |
2511 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2512 } | |
2513 } | |
2514 | |
2515 static void pred8x8_128_dc_c(uint8_t *src, int stride){ | |
2516 int i; | |
2517 | |
2755 | 2518 for(i=0; i<8; i++){ |
2967 | 2519 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2520 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2521 } | |
2522 } | |
2523 | |
2524 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2525 int i; | |
2526 int dc0, dc2; | |
2527 | |
2528 dc0=dc2=0; | |
2529 for(i=0;i<4; i++){ | |
2530 dc0+= src[-1+i*stride]; | |
2531 dc2+= src[-1+(i+4)*stride]; | |
2532 } | |
2533 dc0= 0x01010101*((dc0 + 2)>>2); | |
2534 dc2= 0x01010101*((dc2 + 2)>>2); | |
2535 | |
2536 for(i=0; i<4; i++){ | |
2537 ((uint32_t*)(src+i*stride))[0]= | |
2538 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2539 } | |
2540 for(i=4; i<8; i++){ | |
2541 ((uint32_t*)(src+i*stride))[0]= | |
2542 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2543 } | |
2544 } | |
2545 | |
2546 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2547 int i; | |
2548 int dc0, dc1; | |
2549 | |
2550 dc0=dc1=0; | |
2551 for(i=0;i<4; i++){ | |
2552 dc0+= src[i-stride]; | |
2553 dc1+= src[4+i-stride]; | |
2554 } | |
2555 dc0= 0x01010101*((dc0 + 2)>>2); | |
2556 dc1= 0x01010101*((dc1 + 2)>>2); | |
2557 | |
2558 for(i=0; i<4; i++){ | |
2559 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2560 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2561 } | |
2562 for(i=4; i<8; i++){ | |
2563 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2564 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2565 } | |
2566 } | |
2567 | |
2568 | |
2569 static void pred8x8_dc_c(uint8_t *src, int stride){ | |
2570 int i; | |
2571 int dc0, dc1, dc2, dc3; | |
2572 | |
2573 dc0=dc1=dc2=0; | |
2574 for(i=0;i<4; i++){ | |
2575 dc0+= src[-1+i*stride] + src[i-stride]; | |
2576 dc1+= src[4+i-stride]; | |
2577 dc2+= src[-1+(i+4)*stride]; | |
2578 } | |
2579 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2580 dc0= 0x01010101*((dc0 + 4)>>3); | |
2581 dc1= 0x01010101*((dc1 + 2)>>2); | |
2582 dc2= 0x01010101*((dc2 + 2)>>2); | |
2583 | |
2584 for(i=0; i<4; i++){ | |
2585 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2586 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2587 } | |
2588 for(i=4; i<8; i++){ | |
2589 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2590 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2591 } | |
2592 } | |
2593 | |
2594 static void 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
|
2595 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2596 int a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2597 uint8_t *cm = cropTbl + MAX_NEG_CROP; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2598 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
|
2599 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
|
2600 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
|
2601 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
|
2602 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
|
2603 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
|
2604 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2605 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
|
2606 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
|
2607 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2608 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2609 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2610 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2611 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
|
2612 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
|
2613 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2614 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2615 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2616 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
|
2617 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
|
2618 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
|
2619 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
|
2620 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
|
2621 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
|
2622 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
|
2623 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2624 } |
1168 | 2625 } |
2626 | |
2755 | 2627 #define SRC(x,y) src[(x)+(y)*stride] |
2628 #define PL(y) \ | |
2629 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2630 #define PREDICT_8x8_LOAD_LEFT \ | |
2631 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2632 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2633 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2634 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2635 |
2636 #define PT(x) \ | |
2637 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2638 #define PREDICT_8x8_LOAD_TOP \ | |
2639 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2640 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2641 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2642 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2643 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2644 |
2645 #define PTR(x) \ | |
2646 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2647 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2648 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2649 if(has_topright) { \ | |
2650 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2651 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2652 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2653 | |
2654 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2655 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2656 |
2657 #define PREDICT_8x8_DC(v) \ | |
2658 int y; \ | |
2659 for( y = 0; y < 8; y++ ) { \ | |
2660 ((uint32_t*)src)[0] = \ | |
2661 ((uint32_t*)src)[1] = v; \ | |
2662 src += stride; \ | |
2663 } | |
2664 | |
2665 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2666 { | |
2667 PREDICT_8x8_DC(0x80808080); | |
2668 } | |
2669 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2670 { | |
2671 PREDICT_8x8_LOAD_LEFT; | |
2672 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2673 PREDICT_8x8_DC(dc); | |
2674 } | |
2675 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2676 { | |
2677 PREDICT_8x8_LOAD_TOP; | |
2678 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2679 PREDICT_8x8_DC(dc); | |
2680 } | |
2681 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2682 { | |
2683 PREDICT_8x8_LOAD_LEFT; | |
2684 PREDICT_8x8_LOAD_TOP; | |
2685 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2686 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2687 PREDICT_8x8_DC(dc); | |
2688 } | |
2689 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2690 { | |
2691 PREDICT_8x8_LOAD_LEFT; | |
2692 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2693 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2694 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2695 #undef ROW | |
2696 } | |
2697 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2698 { | |
2699 int y; | |
2700 PREDICT_8x8_LOAD_TOP; | |
2701 src[0] = t0; | |
2702 src[1] = t1; | |
2703 src[2] = t2; | |
2704 src[3] = t3; | |
2705 src[4] = t4; | |
2706 src[5] = t5; | |
2707 src[6] = t6; | |
2708 src[7] = t7; | |
2709 for( y = 1; y < 8; y++ ) | |
2710 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2711 } | |
2712 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2713 { | |
2714 PREDICT_8x8_LOAD_TOP; | |
2715 PREDICT_8x8_LOAD_TOPRIGHT; | |
2716 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2717 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2718 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2719 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2720 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2721 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2722 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; | |
2723 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; | |
2724 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; | |
2725 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2726 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2727 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2728 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2729 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2730 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2731 } | |
2732 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2733 { | |
2734 PREDICT_8x8_LOAD_TOP; | |
2735 PREDICT_8x8_LOAD_LEFT; | |
2736 PREDICT_8x8_LOAD_TOPLEFT; | |
2737 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2738 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2739 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2740 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2741 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2742 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2743 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; | |
2744 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; | |
2745 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; | |
2746 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2747 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2748 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2749 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2750 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2751 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2752 |
2755 | 2753 } |
2754 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2755 { | |
2756 PREDICT_8x8_LOAD_TOP; | |
2757 PREDICT_8x8_LOAD_LEFT; | |
2758 PREDICT_8x8_LOAD_TOPLEFT; | |
2759 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2760 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2761 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2762 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2763 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2764 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2765 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2766 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2767 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2768 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2769 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2770 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2771 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2772 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2773 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2774 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2775 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2776 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2777 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2778 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2779 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2780 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2781 } | |
2782 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2783 { | |
2784 PREDICT_8x8_LOAD_TOP; | |
2785 PREDICT_8x8_LOAD_LEFT; | |
2786 PREDICT_8x8_LOAD_TOPLEFT; | |
2787 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2788 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2789 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2790 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2791 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2792 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2793 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2794 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2795 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2796 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2797 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2798 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2799 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2800 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2801 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2802 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2803 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2804 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2805 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2806 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2807 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2808 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2809 } | |
2810 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2811 { | |
2812 PREDICT_8x8_LOAD_TOP; | |
2813 PREDICT_8x8_LOAD_TOPRIGHT; | |
2814 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2815 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2816 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2817 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2818 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2819 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2820 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2821 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2822 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2823 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2824 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2825 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2826 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2827 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2828 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2829 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2830 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2831 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2832 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2833 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2834 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2835 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2836 } | |
2837 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2838 { | |
2839 PREDICT_8x8_LOAD_LEFT; | |
2840 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2841 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2842 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2843 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2844 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2845 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2846 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2847 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2848 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2849 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2850 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2851 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2852 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2853 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2854 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2855 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2856 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2857 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2858 } | |
2859 #undef PREDICT_8x8_LOAD_LEFT | |
2860 #undef PREDICT_8x8_LOAD_TOP | |
2861 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2862 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2863 #undef PREDICT_8x8_DC | |
2864 #undef PTR | |
2865 #undef PT | |
2866 #undef PL | |
2867 #undef SRC | |
2868 | |
1168 | 2869 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2870 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2871 int src_x_offset, int src_y_offset, | |
2872 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2873 MpegEncContext * const s = &h->s; | |
2874 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2875 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2876 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2877 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2878 uint8_t * src_cb, * src_cr; | |
2879 int extra_width= h->emu_edge_width; | |
2880 int extra_height= h->emu_edge_height; | |
1168 | 2881 int emu=0; |
2882 const int full_mx= mx>>2; | |
2883 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2884 const int pic_width = 16*s->mb_width; |
3316 | 2885 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2886 |
3125 | 2887 if(!pic->data[0]) |
2888 return; | |
2967 | 2889 |
1168 | 2890 if(mx&7) extra_width -= 3; |
2891 if(my&7) extra_height -= 3; | |
2967 | 2892 |
2893 if( full_mx < 0-extra_width | |
2894 || full_my < 0-extra_height | |
2895 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2896 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2897 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); |
2898 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2899 emu=1; |
2900 } | |
2967 | 2901 |
3316 | 2902 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2903 if(!square){ |
3316 | 2904 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2905 } |
2967 | 2906 |
1168 | 2907 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2908 |
3316 | 2909 if(MB_MBAFF){ |
2910 // chroma offset when predicting from a field of opposite parity | |
2911 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2912 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2913 } | |
2914 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2915 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2916 |
2917 if(emu){ | |
3316 | 2918 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); |
2919 src_cb= s->edge_emu_buffer; | |
2920 } | |
2921 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2922 | |
2923 if(emu){ | |
2924 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 | 2925 src_cr= s->edge_emu_buffer; |
2926 } | |
3316 | 2927 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2928 } |
2929 | |
2415 | 2930 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2931 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2932 int x_offset, int y_offset, | |
2933 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2934 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2935 int list0, int list1){ | |
2936 MpegEncContext * const s = &h->s; | |
2937 qpel_mc_func *qpix_op= qpix_put; | |
2938 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2939 |
3316 | 2940 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2941 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2942 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2943 x_offset += 8*s->mb_x; |
3316 | 2944 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2945 |
1168 | 2946 if(list0){ |
1169 | 2947 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2948 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2949 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2950 qpix_op, chroma_op); | |
2951 | |
2952 qpix_op= qpix_avg; | |
2953 chroma_op= chroma_avg; | |
2954 } | |
2955 | |
2956 if(list1){ | |
1169 | 2957 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2958 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2959 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2960 qpix_op, chroma_op); | |
2961 } | |
2962 } | |
2963 | |
2415 | 2964 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2965 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2966 int x_offset, int y_offset, | |
2967 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2968 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2969 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2970 int list0, int list1){ | |
2971 MpegEncContext * const s = &h->s; | |
2972 | |
3316 | 2973 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2974 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2975 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2976 x_offset += 8*s->mb_x; |
3316 | 2977 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2978 |
2415 | 2979 if(list0 && list1){ |
2980 /* don't optimize for luma-only case, since B-frames usually | |
2981 * use implicit weights => chroma too. */ | |
2982 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2983 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2984 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2985 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2986 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2987 | |
2988 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2989 dest_y, dest_cb, dest_cr, | |
2990 x_offset, y_offset, qpix_put, chroma_put); | |
2991 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2992 tmp_y, tmp_cb, tmp_cr, | |
2993 x_offset, y_offset, qpix_put, chroma_put); | |
2994 | |
2995 if(h->use_weight == 2){ | |
2996 int weight0 = h->implicit_weight[refn0][refn1]; | |
2997 int weight1 = 64 - weight0; | |
3316 | 2998 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2999 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
3000 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 3001 }else{ |
3316 | 3002 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 3003 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 3004 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 3005 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 3006 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 3007 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 3008 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 3009 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 3010 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 3011 } |
3012 }else{ | |
3013 int list = list1 ? 1 : 0; | |
3014 int refn = h->ref_cache[list][ scan8[n] ]; | |
3015 Picture *ref= &h->ref_list[list][refn]; | |
3016 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
3017 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3018 qpix_put, chroma_put); | |
3019 | |
3316 | 3020 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 3021 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
3022 if(h->use_weight_chroma){ | |
3316 | 3023 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 3024 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 3025 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 3026 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
3027 } | |
3028 } | |
3029 } | |
3030 | |
3031 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
3032 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
3033 int x_offset, int y_offset, | |
3034 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
3035 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 3036 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 3037 int list0, int list1){ |
3038 if((h->use_weight==2 && list0 && list1 | |
3039 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
3040 || h->use_weight==1) | |
3041 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
3042 x_offset, y_offset, qpix_put, chroma_put, | |
3043 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
3044 else | |
3045 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
3046 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
3047 } | |
3048 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3049 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
|
3050 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3051 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3052 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3053 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
|
3054 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3055 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
|
3056 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
|
3057 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 3058 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
|
3059 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
|
3060 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
|
3061 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
|
3062 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3063 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3064 |
1168 | 3065 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
3066 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 3067 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
3068 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 3069 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
|
3070 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 3071 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 3072 |
1168 | 3073 assert(IS_INTER(mb_type)); |
2967 | 3074 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3075 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3076 |
1168 | 3077 if(IS_16X16(mb_type)){ |
3078 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
3079 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 3080 &weight_op[0], &weight_avg[0], |
1168 | 3081 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3082 }else if(IS_16X8(mb_type)){ | |
3083 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
3084 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 3085 &weight_op[1], &weight_avg[1], |
1168 | 3086 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3087 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
3088 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 3089 &weight_op[1], &weight_avg[1], |
1168 | 3090 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
3091 }else if(IS_8X16(mb_type)){ | |
3316 | 3092 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 3093 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 3094 &weight_op[2], &weight_avg[2], |
1168 | 3095 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 3096 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 3097 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 3098 &weight_op[2], &weight_avg[2], |
1168 | 3099 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
3100 }else{ | |
3101 int i; | |
2967 | 3102 |
1168 | 3103 assert(IS_8X8(mb_type)); |
3104 | |
3105 for(i=0; i<4; i++){ | |
3106 const int sub_mb_type= h->sub_mb_type[i]; | |
3107 const int n= 4*i; | |
3108 int x_offset= (i&1)<<2; | |
3109 int y_offset= (i&2)<<1; | |
3110 | |
3111 if(IS_SUB_8X8(sub_mb_type)){ | |
3112 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3113 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 3114 &weight_op[3], &weight_avg[3], |
1168 | 3115 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3116 }else if(IS_SUB_8X4(sub_mb_type)){ | |
3117 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3118 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3119 &weight_op[4], &weight_avg[4], |
1168 | 3120 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3121 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
3122 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3123 &weight_op[4], &weight_avg[4], |
1168 | 3124 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3125 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 3126 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 3127 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3128 &weight_op[5], &weight_avg[5], |
1168 | 3129 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 3130 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 3131 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3132 &weight_op[5], &weight_avg[5], |
1168 | 3133 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3134 }else{ | |
3135 int j; | |
3136 assert(IS_SUB_4X4(sub_mb_type)); | |
3137 for(j=0; j<4; j++){ | |
3138 int sub_x_offset= x_offset + 2*(j&1); | |
3139 int sub_y_offset= y_offset + (j&2); | |
3140 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
3141 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 3142 &weight_op[6], &weight_avg[6], |
1168 | 3143 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3144 } | |
3145 } | |
3146 } | |
3147 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3148 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3149 prefetch_motion(h, 1); |
1168 | 3150 } |
3151 | |
3152 static void decode_init_vlc(H264Context *h){ | |
3153 static int done = 0; | |
3154 | |
3155 if (!done) { | |
3156 int i; | |
3157 done = 1; | |
3158 | |
2967 | 3159 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 3160 &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
|
3161 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 3162 |
3163 for(i=0; i<4; i++){ | |
2967 | 3164 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 3165 &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
|
3166 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 3167 } |
3168 | |
3169 for(i=0; i<3; i++){ | |
3170 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
3171 &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
|
3172 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3173 } |
3174 for(i=0; i<15; i++){ | |
2967 | 3175 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 3176 &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
|
3177 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3178 } |
3179 | |
3180 for(i=0; i<6; i++){ | |
2967 | 3181 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 3182 &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
|
3183 &run_bits[i][0], 1, 1, 1); |
1168 | 3184 } |
2967 | 3185 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 3186 &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
|
3187 &run_bits[6][0], 1, 1, 1); |
1168 | 3188 } |
3189 } | |
3190 | |
3191 /** | |
3192 * Sets the intra prediction function pointers. | |
3193 */ | |
3194 static void init_pred_ptrs(H264Context *h){ | |
3195 // MpegEncContext * const s = &h->s; | |
3196 | |
3197 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
3198 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
3199 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
3200 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
3201 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
3202 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
3203 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
3204 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
3205 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
3206 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
3207 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
3208 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
3209 | |
2755 | 3210 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
3211 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
3212 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
3213 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
3214 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
3215 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
3216 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
3217 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
3218 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
3219 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
3220 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
3221 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
3222 | |
1168 | 3223 h->pred8x8[DC_PRED8x8 ]= pred8x8_dc_c; |
3224 h->pred8x8[VERT_PRED8x8 ]= pred8x8_vertical_c; | |
3225 h->pred8x8[HOR_PRED8x8 ]= pred8x8_horizontal_c; | |
3226 h->pred8x8[PLANE_PRED8x8 ]= pred8x8_plane_c; | |
3227 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; | |
3228 h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c; | |
3229 h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c; | |
3230 | |
3231 h->pred16x16[DC_PRED8x8 ]= pred16x16_dc_c; | |
3232 h->pred16x16[VERT_PRED8x8 ]= pred16x16_vertical_c; | |
3233 h->pred16x16[HOR_PRED8x8 ]= pred16x16_horizontal_c; | |
3234 h->pred16x16[PLANE_PRED8x8 ]= pred16x16_plane_c; | |
3235 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; | |
3236 h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c; | |
3237 h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c; | |
3238 } | |
3239 | |
3240 static void free_tables(H264Context *h){ | |
3241 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
|
3242 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
|
3243 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
|
3244 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
|
3245 av_freep(&h->mvd_table[1]); |
2396 | 3246 av_freep(&h->direct_table); |
1168 | 3247 av_freep(&h->non_zero_count); |
3248 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
|
3249 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3250 av_freep(&h->top_borders[0]); |
1168 | 3251 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
|
3252 |
1168 | 3253 av_freep(&h->mb2b_xy); |
3254 av_freep(&h->mb2b8_xy); | |
2415 | 3255 |
3256 av_freep(&h->s.obmc_scratchpad); | |
1168 | 3257 } |
3258 | |
2919 | 3259 static void init_dequant8_coeff_table(H264Context *h){ |
3260 int i,q,x; | |
3174 | 3261 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 3262 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
3263 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
3264 | |
3265 for(i=0; i<2; i++ ){ | |
3266 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
3267 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
3268 break; | |
3269 } | |
3270 | |
3271 for(q=0; q<52; q++){ | |
3272 int shift = div6[q]; | |
3273 int idx = rem6[q]; | |
3274 for(x=0; x<64; x++) | |
3174 | 3275 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
3276 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
3277 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 3278 } |
3279 } | |
3280 } | |
3281 | |
3282 static void init_dequant4_coeff_table(H264Context *h){ | |
3283 int i,j,q,x; | |
3005 | 3284 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 3285 for(i=0; i<6; i++ ){ |
3286 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
3287 for(j=0; j<i; j++){ | |
3288 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
3289 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
3290 break; | |
3291 } | |
3292 } | |
3293 if(j<i) | |
3294 continue; | |
3295 | |
3296 for(q=0; q<52; q++){ | |
3297 int shift = div6[q] + 2; | |
3298 int idx = rem6[q]; | |
3299 for(x=0; x<16; x++) | |
3005 | 3300 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
3301 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 3302 h->pps.scaling_matrix4[i][x]) << shift; |
3303 } | |
3304 } | |
3305 } | |
3306 | |
3307 static void init_dequant_tables(H264Context *h){ | |
3308 int i,x; | |
3309 init_dequant4_coeff_table(h); | |
3310 if(h->pps.transform_8x8_mode) | |
3311 init_dequant8_coeff_table(h); | |
3312 if(h->sps.transform_bypass){ | |
3313 for(i=0; i<6; i++) | |
3314 for(x=0; x<16; x++) | |
3315 h->dequant4_coeff[i][0][x] = 1<<6; | |
3316 if(h->pps.transform_8x8_mode) | |
3317 for(i=0; i<2; i++) | |
3318 for(x=0; x<64; x++) | |
3319 h->dequant8_coeff[i][0][x] = 1<<6; | |
3320 } | |
3321 } | |
3322 | |
3323 | |
1168 | 3324 /** |
3325 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3326 * needs width/height |
1168 | 3327 */ |
3328 static int alloc_tables(H264Context *h){ | |
3329 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
|
3330 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 3331 int x,y; |
1168 | 3332 |
3333 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
|
3334 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3335 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 3336 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
|
3337 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
|
3338 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 3339 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 3340 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3341 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
|
3342 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
|
3343 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
|
3344 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 3345 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
|
3346 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3347 |
3316 | 3348 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
3349 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 3350 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
3351 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
|
3352 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 3353 for(y=0; y<s->mb_height; y++){ |
3354 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
|
3355 const int mb_xy= x + y*s->mb_stride; |
1168 | 3356 const int b_xy = 4*x + 4*y*h->b_stride; |
3357 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 3358 |
1168 | 3359 h->mb2b_xy [mb_xy]= b_xy; |
3360 h->mb2b8_xy[mb_xy]= b8_xy; | |
3361 } | |
3362 } | |
2415 | 3363 |
2417 | 3364 s->obmc_scratchpad = NULL; |
3365 | |
2920 | 3366 if(!h->dequant4_coeff[0]) |
3367 init_dequant_tables(h); | |
3368 | |
1168 | 3369 return 0; |
3370 fail: | |
3371 free_tables(h); | |
3372 return -1; | |
3373 } | |
3374 | |
3375 static void common_init(H264Context *h){ | |
3376 MpegEncContext * const s = &h->s; | |
3377 | |
3378 s->width = s->avctx->width; | |
3379 s->height = s->avctx->height; | |
3380 s->codec_id= s->avctx->codec->id; | |
2967 | 3381 |
1168 | 3382 init_pred_ptrs(h); |
3383 | |
2919 | 3384 h->dequant_coeff_pps= -1; |
1698 | 3385 s->unrestricted_mv=1; |
1168 | 3386 s->decode=1; //FIXME |
2920 | 3387 |
3388 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
3389 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 3390 } |
3391 | |
3392 static int decode_init(AVCodecContext *avctx){ | |
3393 H264Context *h= avctx->priv_data; | |
3394 MpegEncContext * const s = &h->s; | |
3395 | |
1892 | 3396 MPV_decode_defaults(s); |
2967 | 3397 |
1168 | 3398 s->avctx = avctx; |
3399 common_init(h); | |
3400 | |
3401 s->out_format = FMT_H264; | |
3402 s->workaround_bugs= avctx->workaround_bugs; | |
3403 | |
3404 // set defaults | |
3405 // s->decode_mb= ff_h263_decode_mb; | |
3406 s->low_delay= 1; | |
3407 avctx->pix_fmt= PIX_FMT_YUV420P; | |
3408 | |
3409 decode_init_vlc(h); | |
2967 | 3410 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3411 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
|
3412 *(char *)avctx->extradata == 1){ |
2227 | 3413 h->is_avc = 1; |
3414 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
|
3415 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3416 h->is_avc = 0; |
2227 | 3417 } |
3418 | |
1168 | 3419 return 0; |
3420 } | |
3421 | |
2935 | 3422 static int frame_start(H264Context *h){ |
1168 | 3423 MpegEncContext * const s = &h->s; |
3424 int i; | |
3425 | |
2935 | 3426 if(MPV_frame_start(s, s->avctx) < 0) |
3427 return -1; | |
1168 | 3428 ff_er_frame_start(s); |
3429 | |
3430 assert(s->linesize && s->uvlinesize); | |
3431 | |
3432 for(i=0; i<16; i++){ | |
3433 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
|
3434 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 3435 } |
3436 for(i=0; i<4; i++){ | |
3437 h->block_offset[16+i]= | |
3438 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
|
3439 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3440 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 3441 } |
3442 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
3443 /* 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
|
3444 * 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
|
3445 if(!s->obmc_scratchpad) |
3316 | 3446 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
3447 | |
3448 /* some macroblocks will be accessed before they're available */ | |
3449 if(FRAME_MBAFF) | |
3450 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
|
3451 |
1168 | 3452 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 3453 return 0; |
1168 | 3454 } |
3455 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3456 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
|
3457 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
|
3458 int i; |
2967 | 3459 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3460 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
|
3461 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
|
3462 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
|
3463 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3464 // 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
|
3465 // 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
|
3466 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
|
3467 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
|
3468 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
|
3469 } |
2967 | 3470 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3471 *(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
|
3472 *(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
|
3473 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3474 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
|
3475 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
|
3476 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
|
3477 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
|
3478 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
|
3479 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
|
3480 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3481 *(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
|
3482 *(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
|
3483 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3484 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3485 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3486 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
|
3487 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
|
3488 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
|
3489 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3490 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
|
3491 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
|
3492 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3493 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
|
3494 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
|
3495 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
|
3496 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3497 #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
|
3498 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3499 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3500 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3501 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3502 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3503 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3504 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
|
3505 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
|
3506 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3507 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3508 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3509 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3510 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
|
3511 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3512 if(s->mb_x+1 < s->mb_width){ |
2755 | 3513 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3514 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3515 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3516 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3517 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
|
3518 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3519 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
|
3520 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
|
3521 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
|
3522 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3523 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3524 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3525 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
|
3526 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
|
3527 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3528 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3529 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3530 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3531 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
|
3532 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3533 int i; |
2967 | 3534 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3535 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3536 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3537 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3538 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3539 // 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
|
3540 // 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
|
3541 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
|
3542 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
|
3543 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3544 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
|
3545 } |
2967 | 3546 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3547 *(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
|
3548 *(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
|
3549 *(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
|
3550 *(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
|
3551 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3552 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3553 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
|
3554 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
|
3555 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
|
3556 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
|
3557 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3558 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
|
3559 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
|
3560 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3561 *(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
|
3562 *(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
|
3563 *(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
|
3564 *(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
|
3565 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3566 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3567 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3568 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
|
3569 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3570 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3571 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3572 int deblock_left = (s->mb_x > 0); |
3316 | 3573 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
|
3574 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3575 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
|
3576 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3577 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3578 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3579 src_cr -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3580 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3581 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3582 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3583 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3584 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3585 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3586 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3587 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3588 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
|
3589 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
|
3590 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3591 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3592 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3593 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3594 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
|
3595 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
|
3596 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
|
3597 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3598 if(s->mb_x+1 < s->mb_width){ |
3599 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3600 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3601 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3602 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3603 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3604 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3605 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3606 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
|
3607 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
|
3608 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
|
3609 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3610 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3611 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3612 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
|
3613 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
|
3614 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
|
3615 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
|
3616 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3617 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3618 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3619 |
1168 | 3620 static void hl_decode_mb(H264Context *h){ |
3621 MpegEncContext * const s = &h->s; | |
3622 const int mb_x= s->mb_x; | |
3623 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
|
3624 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3625 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3626 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3627 int linesize, uvlinesize /*dct_offset*/; | |
3628 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3629 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
|
3630 const unsigned int bottom = mb_y & 1; |
2763 | 3631 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass); |
3632 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
|
3633 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3634 |
3635 if(!s->decode) | |
3636 return; | |
3637 | |
3638 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3639 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3640 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3641 | |
4000 | 3642 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3643 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3644 | |
3316 | 3645 if (MB_FIELD) { |
3646 linesize = h->mb_linesize = s->linesize * 2; | |
3647 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
|
3648 block_offset = &h->block_offset[24]; |
1168 | 3649 if(mb_y&1){ //FIXME move out of this func? |
3650 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3651 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3652 dest_cr-= s->uvlinesize*7; |
1168 | 3653 } |
3316 | 3654 if(FRAME_MBAFF) { |
3655 int list; | |
3656 for(list=0; list<2; list++){ | |
3657 if(!USES_LIST(mb_type, list)) | |
3658 continue; | |
3659 if(IS_16X16(mb_type)){ | |
3660 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3661 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3662 }else{ | |
3663 for(i=0; i<16; i+=4){ | |
3664 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3665 int ref = h->ref_cache[list][scan8[i]]; | |
3666 if(ref >= 0) | |
3667 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3668 } | |
3669 } | |
3670 } | |
3671 } | |
1168 | 3672 } else { |
3316 | 3673 linesize = h->mb_linesize = s->linesize; |
3674 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3675 // dct_offset = s->linesize * 16; |
3676 } | |
2967 | 3677 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3678 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3679 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3680 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
|
3681 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3682 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3683 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3684 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3685 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3686 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3687 } |
1168 | 3688 |
3316 | 3689 if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3690 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ | |
3691 int mbt_y = mb_y&~1; | |
3692 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3693 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3694 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3695 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3696 } | |
3697 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3698 if (IS_INTRA_PCM(mb_type)) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3699 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3700 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3701 // 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
|
3702 // 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
|
3703 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3704 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3705 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
|
3706 *(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
|
3707 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3708 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3709 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3710 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3711 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3712 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
|
3713 *(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
|
3714 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3715 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3716 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3717 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3718 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3719 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
|
3720 *(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
|
3721 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3722 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3723 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3724 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3725 if(IS_INTRA(mb_type)){ |
3316 | 3726 if(h->deblocking_filter && !FRAME_MBAFF) |
3727 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
|
3728 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3729 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
|
3730 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
|
3731 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
|
3732 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3733 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3734 if(IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3735 if(!s->encoding){ |
2755 | 3736 if(IS_8x8DCT(mb_type)){ |
3737 for(i=0; i<16; i+=4){ | |
3738 uint8_t * const ptr= dest_y + block_offset[i]; | |
3739 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
|
3740 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3741 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
3742 (h->topright_samples_available<<(i+1))&0x8000, linesize); | |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3743 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3744 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3745 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3746 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3747 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3748 } |
2755 | 3749 } |
3750 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3751 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
|
3752 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
|
3753 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3754 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
|
3755 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3756 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3757 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
|
3758 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
|
3759 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
|
3760 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3761 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3762 topright= (uint8_t*) &tr; |
2967 | 3763 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3764 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3765 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3766 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3767 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3768 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3769 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3770 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3771 if(s->codec_id == CODEC_ID_H264){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3772 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3773 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3774 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3775 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3776 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3777 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
|
3778 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3779 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3780 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3781 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3782 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
2763 | 3783 if(s->codec_id == CODEC_ID_H264){ |
3784 if(!transform_bypass) | |
2919 | 3785 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3786 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3787 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
|
3788 } |
3316 | 3789 if(h->deblocking_filter && !FRAME_MBAFF) |
3790 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
|
3791 }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
|
3792 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
|
3793 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
|
3794 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
|
3795 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
|
3796 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3797 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3798 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3799 if(!IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3800 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3801 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3802 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3803 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3804 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
|
3805 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3806 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
|
3807 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3808 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3809 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3810 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3811 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3812 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3813 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3814 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
|
3815 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3816 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
|
3817 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3818 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3819 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3820 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3821 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
|
3822 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
|
3823 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
|
3824 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3825 } |
1168 | 3826 } |
3827 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3828 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3829 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3830 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3831 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3832 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3833 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3834 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3835 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3836 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3837 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]); |
3838 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 | 3839 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3840 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3841 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3842 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3843 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
|
3844 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3845 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
|
3846 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3847 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3848 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
|
3849 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
|
3850 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
|
3851 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
|
3852 } |
1250 | 3853 } |
1168 | 3854 } |
3855 } | |
3856 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3857 if(h->deblocking_filter) { |
3316 | 3858 if (FRAME_MBAFF) { |
3859 //FIXME try deblocking one mb at a time? | |
3860 // 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
|
3861 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
|
3862 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
|
3863 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
|
3864 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
|
3865 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
|
3866 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3867 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
|
3868 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
|
3869 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
|
3870 |
3316 | 3871 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3872 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3873 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3874 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3875 // deblock a pair |
2967 | 3876 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3877 s->mb_y--; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3878 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
|
3879 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3880 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
|
3881 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
|
3882 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3883 s->mb_y++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3884 tprintf("call mbaff filter_mb\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3885 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3886 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
|
3887 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
|
3888 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3889 tprintf("call filter_mb\n"); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3890 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
|
3891 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
|
3892 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
|
3893 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3894 } |
1168 | 3895 } |
3896 | |
3897 /** | |
3898 * fills the default_ref_list. | |
3899 */ | |
3900 static int fill_default_ref_list(H264Context *h){ | |
3901 MpegEncContext * const s = &h->s; | |
3902 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
|
3903 int smallest_poc_greater_than_current = -1; |
2582 | 3904 Picture sorted_short_ref[32]; |
2967 | 3905 |
1168 | 3906 if(h->slice_type==B_TYPE){ |
3907 int out_i; | |
2713 | 3908 int limit= INT_MIN; |
1168 | 3909 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3910 /* sort frame according to poc in B slice */ |
1168 | 3911 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3912 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
|
3913 int best_poc=INT_MAX; |
1168 | 3914 |
3915 for(i=0; i<h->short_ref_count; i++){ | |
3916 const int poc= h->short_ref[i]->poc; | |
3917 if(poc > limit && poc < best_poc){ | |
3918 best_poc= poc; | |
3919 best_i= i; | |
3920 } | |
3921 } | |
2967 | 3922 |
2713 | 3923 assert(best_i != INT_MIN); |
2967 | 3924 |
1168 | 3925 limit= best_poc; |
3926 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
|
3927 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
|
3928 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
|
3929 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
|
3930 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
|
3931 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3932 } |
1168 | 3933 } |
3934 } | |
3935 | |
3936 if(s->picture_structure == PICT_FRAME){ | |
3937 if(h->slice_type==B_TYPE){ | |
3938 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
|
3939 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
|
3940 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3941 // find the largest poc |
1168 | 3942 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
|
3943 int index = 0; |
2447 | 3944 int j= -99; |
3945 int step= list ? -1 : 1; | |
3946 | |
3947 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3948 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
|
3949 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3950 return -1; |
2447 | 3951 step = -step; |
3952 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
|
3953 } |
2447 | 3954 if(sorted_short_ref[j].reference != 3) continue; |
3955 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3956 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3957 } |
3958 | |
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
|
3959 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
|
3960 if(h->long_ref[i] == NULL) continue; |
1168 | 3961 if(h->long_ref[i]->reference != 3) continue; |
3962 | |
3963 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3964 h->default_ref_list[ list ][index++].pic_id= i;; | |
3965 } | |
2967 | 3966 |
2447 | 3967 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
|
3968 // 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
|
3969 // L0 and L1 are identical |
1168 | 3970 Picture temp= h->default_ref_list[1][0]; |
3971 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3972 h->default_ref_list[1][1] = temp; |
1168 | 3973 } |
3974 | |
3975 if(index < h->ref_count[ list ]) | |
3976 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3977 } | |
3978 }else{ | |
3979 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3980 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3981 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3982 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3983 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3984 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3985 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
|
3986 if(h->long_ref[i] == NULL) continue; |
1168 | 3987 if(h->long_ref[i]->reference != 3) continue; |
3988 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3989 h->default_ref_list[0][index++].pic_id= i;; | |
3990 } | |
3991 if(index < h->ref_count[0]) | |
3992 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3993 } | |
3994 }else{ //FIELD | |
3995 if(h->slice_type==B_TYPE){ | |
3996 }else{ | |
3997 //FIXME second field balh | |
3998 } | |
3999 } | |
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
|
4000 #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
|
4001 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
|
4002 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
|
4003 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4004 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
|
4005 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
|
4006 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
|
4007 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4008 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4009 #endif |
1168 | 4010 return 0; |
4011 } | |
4012 | |
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
|
4013 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
|
4014 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
|
4015 |
1168 | 4016 static int decode_ref_pic_list_reordering(H264Context *h){ |
4017 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4018 int list, index; |
2967 | 4019 |
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
|
4020 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
|
4021 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4022 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 4023 |
1168 | 4024 for(list=0; list<2; list++){ |
4025 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); | |
4026 | |
4027 if(get_bits1(&s->gb)){ | |
4028 int pred= h->curr_pic_num; | |
4029 | |
4030 for(index=0; ; index++){ | |
4031 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); | |
4032 int pic_id; | |
4033 int i; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
4034 Picture *ref = NULL; |
2967 | 4035 |
4036 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
|
4037 break; |
2967 | 4038 |
1168 | 4039 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4040 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 4041 return -1; |
4042 } | |
2967 | 4043 |
1168 | 4044 if(reordering_of_pic_nums_idc<3){ |
4045 if(reordering_of_pic_nums_idc<2){ | |
4046 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; | |
4047 | |
4048 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
|
4049 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 4050 return -1; |
4051 } | |
4052 | |
4053 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
4054 else pred+= abs_diff_pic_num; | |
4055 pred &= h->max_pic_num - 1; | |
2967 | 4056 |
2683 | 4057 for(i= h->short_ref_count-1; i>=0; i--){ |
4058 ref = h->short_ref[i]; | |
4059 assert(ref->reference == 3); | |
4060 assert(!ref->long_ref); | |
4061 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 4062 break; |
4063 } | |
2683 | 4064 if(i>=0) |
4065 ref->pic_id= ref->frame_num; | |
1168 | 4066 }else{ |
4067 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
2683 | 4068 ref = h->long_ref[pic_id]; |
4069 ref->pic_id= pic_id; | |
4070 assert(ref->reference == 3); | |
4071 assert(ref->long_ref); | |
4072 i=0; | |
1168 | 4073 } |
4074 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
4075 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4076 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 4077 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 4078 } else { |
4079 for(i=index; i+1<h->ref_count[list]; i++){ | |
4080 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
4081 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
|
4082 } |
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
|
4083 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
|
4084 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
|
4085 } |
2683 | 4086 h->ref_list[list][index]= *ref; |
1168 | 4087 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
4088 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4089 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 4090 return -1; |
4091 } | |
4092 } | |
4093 } | |
4094 | |
4095 if(h->slice_type!=B_TYPE) break; | |
4096 } | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4097 for(list=0; list<2; list++){ |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4098 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
|
4099 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4100 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4101 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4102 if(h->slice_type!=B_TYPE) break; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4103 } |
2967 | 4104 |
2396 | 4105 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
4106 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
4107 direct_ref_list_init(h); |
2967 | 4108 return 0; |
1168 | 4109 } |
4110 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
4111 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 4112 int list, i, j; |
4113 for(list=0; list<2; list++){ | |
4114 for(i=0; i<h->ref_count[list]; i++){ | |
4115 Picture *frame = &h->ref_list[list][i]; | |
4116 Picture *field = &h->ref_list[list][16+2*i]; | |
4117 field[0] = *frame; | |
4118 for(j=0; j<3; j++) | |
4119 field[0].linesize[j] <<= 1; | |
4120 field[1] = field[0]; | |
4121 for(j=0; j<3; j++) | |
4122 field[1].data[j] += frame->linesize[j]; | |
4123 | |
4124 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4125 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4126 for(j=0; j<2; j++){ | |
4127 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4128 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4129 } | |
4130 } | |
4131 } | |
4132 for(j=0; j<h->ref_count[1]; j++){ | |
4133 for(i=0; i<h->ref_count[0]; i++) | |
4134 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4135 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4136 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4137 } | |
4138 } | |
4139 | |
1168 | 4140 static int pred_weight_table(H264Context *h){ |
4141 MpegEncContext * const s = &h->s; | |
4142 int list, i; | |
2415 | 4143 int luma_def, chroma_def; |
2967 | 4144 |
2415 | 4145 h->use_weight= 0; |
4146 h->use_weight_chroma= 0; | |
1168 | 4147 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4148 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4149 luma_def = 1<<h->luma_log2_weight_denom; |
4150 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4151 |
4152 for(list=0; list<2; list++){ | |
4153 for(i=0; i<h->ref_count[list]; i++){ | |
4154 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4155 |
1168 | 4156 luma_weight_flag= get_bits1(&s->gb); |
4157 if(luma_weight_flag){ | |
4158 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4159 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4160 if( h->luma_weight[list][i] != luma_def |
4161 || h->luma_offset[list][i] != 0) | |
4162 h->use_weight= 1; | |
4163 }else{ | |
4164 h->luma_weight[list][i]= luma_def; | |
4165 h->luma_offset[list][i]= 0; | |
1168 | 4166 } |
4167 | |
4168 chroma_weight_flag= get_bits1(&s->gb); | |
4169 if(chroma_weight_flag){ | |
4170 int j; | |
4171 for(j=0; j<2; j++){ | |
4172 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4173 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4174 if( h->chroma_weight[list][i][j] != chroma_def |
4175 || h->chroma_offset[list][i][j] != 0) | |
4176 h->use_weight_chroma= 1; | |
4177 } | |
4178 }else{ | |
4179 int j; | |
4180 for(j=0; j<2; j++){ | |
4181 h->chroma_weight[list][i][j]= chroma_def; | |
4182 h->chroma_offset[list][i][j]= 0; | |
1168 | 4183 } |
4184 } | |
4185 } | |
4186 if(h->slice_type != B_TYPE) break; | |
4187 } | |
2415 | 4188 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4189 return 0; |
4190 } | |
4191 | |
2415 | 4192 static void implicit_weight_table(H264Context *h){ |
4193 MpegEncContext * const s = &h->s; | |
4194 int ref0, ref1; | |
4195 int cur_poc = s->current_picture_ptr->poc; | |
4196 | |
4197 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4198 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4199 h->use_weight= 0; | |
4200 h->use_weight_chroma= 0; | |
4201 return; | |
4202 } | |
4203 | |
4204 h->use_weight= 2; | |
4205 h->use_weight_chroma= 2; | |
4206 h->luma_log2_weight_denom= 5; | |
4207 h->chroma_log2_weight_denom= 5; | |
4208 | |
4209 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4210 int poc0 = h->ref_list[0][ref0].poc; | |
4211 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4212 int poc1 = h->ref_list[1][ref1].poc; |
2415 | 4213 int td = clip(poc1 - poc0, -128, 127); |
4214 if(td){ | |
4215 int tb = clip(cur_poc - poc0, -128, 127); | |
4001 | 4216 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2415 | 4217 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
4218 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
4219 h->implicit_weight[ref0][ref1] = 32; | |
4220 else | |
4221 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4222 }else | |
4223 h->implicit_weight[ref0][ref1] = 32; | |
4224 } | |
4225 } | |
4226 } | |
4227 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4228 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
|
4229 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4230 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4231 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
|
4232 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4233 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4234 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
|
4235 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
|
4236 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4237 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4238 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4239 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4240 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4241 |
1168 | 4242 /** |
2392 | 4243 * instantaneous decoder refresh. |
1168 | 4244 */ |
4245 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
|
4246 int i; |
1168 | 4247 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4248 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4249 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
|
4250 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
|
4251 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4252 } |
1168 | 4253 } |
4254 h->long_ref_count=0; | |
4255 | |
4256 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
|
4257 unreference_pic(h, h->short_ref[i]); |
1168 | 4258 h->short_ref[i]= NULL; |
4259 } | |
4260 h->short_ref_count=0; | |
4261 } | |
4262 | |
2640 | 4263 /* forget old pics after a seek */ |
4264 static void flush_dpb(AVCodecContext *avctx){ | |
4265 H264Context *h= avctx->priv_data; | |
4266 int i; | |
3144 | 4267 for(i=0; i<16; i++) { |
4268 if(h->delayed_pic[i]) | |
4269 h->delayed_pic[i]->reference= 0; | |
2640 | 4270 h->delayed_pic[i]= NULL; |
3144 | 4271 } |
4272 if(h->delayed_output_pic) | |
4273 h->delayed_output_pic->reference= 0; | |
2640 | 4274 h->delayed_output_pic= NULL; |
4275 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4276 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4277 h->s.current_picture_ptr->reference= 0; |
2640 | 4278 } |
4279 | |
1168 | 4280 /** |
4281 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4282 * @return the removed picture or NULL if an error occurs |
1168 | 4283 */ |
4284 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4285 MpegEncContext * const s = &h->s; |
1168 | 4286 int i; |
2967 | 4287 |
1169 | 4288 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
|
4289 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4290 |
1168 | 4291 for(i=0; i<h->short_ref_count; i++){ |
4292 Picture *pic= h->short_ref[i]; | |
1169 | 4293 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
|
4294 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4295 if(pic->frame_num == frame_num){ |
4296 h->short_ref[i]= NULL; | |
4297 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4298 h->short_ref_count--; | |
4299 return pic; | |
4300 } | |
4301 } | |
4302 return NULL; | |
4303 } | |
4304 | |
4305 /** | |
4306 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4307 * @return the removed picture or NULL if an error occurs |
1168 | 4308 */ |
4309 static Picture * remove_long(H264Context *h, int i){ | |
4310 Picture *pic; | |
4311 | |
4312 pic= h->long_ref[i]; | |
4313 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
|
4314 if(pic) h->long_ref_count--; |
1168 | 4315 |
4316 return pic; | |
4317 } | |
4318 | |
4319 /** | |
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
|
4320 * 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
|
4321 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4322 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
|
4323 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
|
4324 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
|
4325 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
|
4326 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
|
4327 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
|
4328 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
|
4329 } |
358813ec4ca2
H.264 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 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4331 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4332 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4333 /** |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4334 * 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
|
4335 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4336 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
|
4337 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
|
4338 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
|
4339 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
|
4340 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
|
4341 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
|
4342 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
|
4343 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
|
4344 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4345 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4346 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4347 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4348 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4349 /** |
1168 | 4350 * Executes the reference picture marking (memory management control operations). |
4351 */ | |
4352 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4353 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
|
4354 int i, j; |
1168 | 4355 int current_is_long=0; |
4356 Picture *pic; | |
2967 | 4357 |
1168 | 4358 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
|
4359 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4360 |
1168 | 4361 for(i=0; i<mmco_count; i++){ |
4362 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
|
4363 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 | 4364 |
4365 switch(mmco[i].opcode){ | |
4366 case MMCO_SHORT2UNUSED: | |
4367 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
|
4368 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4369 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4370 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
|
4371 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4372 break; |
4373 case MMCO_SHORT2LONG: | |
4374 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
|
4375 if(pic) unreference_pic(h, pic); |
2967 | 4376 |
1168 | 4377 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); |
4378 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4379 h->long_ref_count++; |
1168 | 4380 break; |
4381 case MMCO_LONG2UNUSED: | |
4382 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
|
4383 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4384 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4385 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
|
4386 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4387 break; |
4388 case MMCO_LONG: | |
4389 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
|
4390 if(pic) unreference_pic(h, pic); |
2967 | 4391 |
1168 | 4392 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4393 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4394 h->long_ref_count++; | |
2967 | 4395 |
1168 | 4396 current_is_long=1; |
4397 break; | |
4398 case MMCO_SET_MAX_LONG: | |
4399 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
|
4400 // 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
|
4401 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
|
4402 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
|
4403 if (pic) unreference_pic(h, pic); |
1168 | 4404 } |
4405 break; | |
4406 case MMCO_RESET: | |
4407 while(h->short_ref_count){ | |
4408 pic= remove_short(h, h->short_ref[0]->frame_num); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4409 unreference_pic(h, pic); |
1168 | 4410 } |
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
|
4411 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
|
4412 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
|
4413 if(pic) unreference_pic(h, pic); |
1168 | 4414 } |
4415 break; | |
4416 default: assert(0); | |
4417 } | |
4418 } | |
2967 | 4419 |
1168 | 4420 if(!current_is_long){ |
4421 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4422 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4423 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4424 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4425 } |
2967 | 4426 |
1168 | 4427 if(h->short_ref_count) |
1169 | 4428 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4429 | |
4430 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4431 h->short_ref[0]->long_ref=0; |
4432 h->short_ref_count++; | |
4433 } | |
2967 | 4434 |
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
|
4435 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
|
4436 print_long_term(h); |
2967 | 4437 return 0; |
1168 | 4438 } |
4439 | |
4440 static int decode_ref_pic_marking(H264Context *h){ | |
4441 MpegEncContext * const s = &h->s; | |
4442 int i; | |
2967 | 4443 |
1168 | 4444 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4445 s->broken_link= get_bits1(&s->gb) -1; | |
4446 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4447 if(h->mmco[0].long_index == -1) | |
4448 h->mmco_index= 0; | |
4449 else{ | |
4450 h->mmco[0].opcode= MMCO_LONG; | |
4451 h->mmco_index= 1; | |
2967 | 4452 } |
1168 | 4453 }else{ |
4454 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4455 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4456 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4457 | |
4458 h->mmco[i].opcode= opcode; | |
4459 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4460 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 | |
4461 /* 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
|
4462 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4463 return -1; |
4464 }*/ | |
4465 } | |
4466 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
4467 h->mmco[i].long_index= get_ue_golomb(&s->gb); | |
4468 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
|
4469 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4470 return -1; |
4471 } | |
4472 } | |
2967 | 4473 |
1168 | 4474 if(opcode > MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4475 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4476 return -1; |
4477 } | |
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
|
4478 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
|
4479 break; |
1168 | 4480 } |
4481 h->mmco_index= i; | |
4482 }else{ | |
4483 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4484 | |
4485 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4486 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4487 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4488 h->mmco_index= 1; | |
4489 }else | |
4490 h->mmco_index= 0; | |
4491 } | |
4492 } | |
2967 | 4493 |
4494 return 0; | |
1168 | 4495 } |
4496 | |
4497 static int init_poc(H264Context *h){ | |
4498 MpegEncContext * const s = &h->s; | |
4499 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4500 int field_poc[2]; | |
4501 | |
4502 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4503 h->frame_num_offset= 0; | |
4504 }else{ | |
4505 if(h->frame_num < h->prev_frame_num) | |
4506 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4507 else | |
4508 h->frame_num_offset= h->prev_frame_num_offset; | |
4509 } | |
4510 | |
4511 if(h->sps.poc_type==0){ | |
4512 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4513 | |
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
|
4514 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
|
4515 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
|
4516 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
|
4517 } |
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
|
4518 |
1168 | 4519 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4520 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4521 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4522 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4523 else | |
4524 h->poc_msb = h->prev_poc_msb; | |
4525 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4526 field_poc[0] = |
1168 | 4527 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4528 if(s->picture_structure == PICT_FRAME) |
1168 | 4529 field_poc[1] += h->delta_poc_bottom; |
4530 }else if(h->sps.poc_type==1){ | |
4531 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4532 int i; | |
4533 | |
4534 if(h->sps.poc_cycle_length != 0) | |
4535 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4536 else | |
4537 abs_frame_num = 0; | |
4538 | |
4539 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4540 abs_frame_num--; | |
2967 | 4541 |
1168 | 4542 expected_delta_per_poc_cycle = 0; |
4543 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4544 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4545 | |
4546 if(abs_frame_num > 0){ | |
4547 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4548 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4549 | |
4550 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4551 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4552 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4553 } else | |
4554 expectedpoc = 0; | |
4555 | |
2967 | 4556 if(h->nal_ref_idc == 0) |
1168 | 4557 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4558 |
1168 | 4559 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4560 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4561 | |
4562 if(s->picture_structure == PICT_FRAME) | |
4563 field_poc[1] += h->delta_poc[1]; | |
4564 }else{ | |
4565 int poc; | |
4566 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4567 poc= 0; | |
4568 }else{ | |
4569 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4570 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4571 } | |
4572 field_poc[0]= poc; | |
4573 field_poc[1]= poc; | |
4574 } | |
2967 | 4575 |
1168 | 4576 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4577 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4578 if(s->picture_structure != PICT_TOP_FIELD) | |
4579 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4580 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4581 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4582 | |
4583 return 0; | |
4584 } | |
4585 | |
4586 /** | |
4587 * decodes a slice header. | |
4588 * this will allso call MPV_common_init() and frame_start() as needed | |
4589 */ | |
4590 static int decode_slice_header(H264Context *h){ | |
4591 MpegEncContext * const s = &h->s; | |
4592 int first_mb_in_slice, pps_id; | |
4593 int num_ref_idx_active_override_flag; | |
4594 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
|
4595 int slice_type; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4596 int default_ref_list_done = 0; |
1168 | 4597 |
4598 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
|
4599 s->dropable= h->nal_ref_idc == 0; |
1168 | 4600 |
4601 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4602 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4603 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
|
4604 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4605 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 | 4606 return -1; |
1168 | 4607 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4608 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4609 slice_type -= 5; |
1168 | 4610 h->slice_type_fixed=1; |
4611 }else | |
4612 h->slice_type_fixed=0; | |
2967 | 4613 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4614 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
|
4615 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
|
4616 || (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
|
4617 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
|
4618 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4619 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
|
4620 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4621 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4622 |
1168 | 4623 pps_id= get_ue_golomb(&s->gb); |
4624 if(pps_id>255){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4625 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4626 return -1; |
4627 } | |
4628 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4629 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
|
4630 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4631 return -1; |
4632 } | |
4633 | |
1168 | 4634 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4635 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
|
4636 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4637 return -1; |
4638 } | |
2919 | 4639 |
4640 if(h->dequant_coeff_pps != pps_id){ | |
4641 h->dequant_coeff_pps = pps_id; | |
4642 init_dequant_tables(h); | |
4643 } | |
2967 | 4644 |
1168 | 4645 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
|
4646 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4647 |
3178 | 4648 h->b_stride= s->mb_width*4; |
4649 h->b8_stride= s->mb_width*2; | |
1168 | 4650 |
1371 | 4651 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4652 if(h->sps.frame_mbs_only_flag) |
1371 | 4653 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4654 else |
1371 | 4655 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4656 |
4657 if (s->context_initialized | |
1548 | 4658 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4659 free_tables(h); |
4660 MPV_common_end(s); | |
4661 } | |
4662 if (!s->context_initialized) { | |
4663 if (MPV_common_init(s) < 0) | |
4664 return -1; | |
2967 | 4665 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4666 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
|
4667 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
|
4668 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
|
4669 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4670 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4671 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4672 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4673 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4674 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4675 #undef T |
4676 } | |
4677 } | |
4678 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4679 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4680 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4681 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4682 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4683 }else{ |
4684 int i; | |
4685 for(i=0; i<64; i++){ | |
4686 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4687 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4688 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4689 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4690 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4691 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4692 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4693 } |
2763 | 4694 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4695 h->zigzag_scan_q0 = zigzag_scan; |
4696 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4697 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4698 h->field_scan_q0 = field_scan; |
4699 h->field_scan8x8_q0 = field_scan8x8; | |
4700 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4701 }else{ |
3316 | 4702 h->zigzag_scan_q0 = h->zigzag_scan; |
4703 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4704 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4705 h->field_scan_q0 = h->field_scan; |
4706 h->field_scan8x8_q0 = h->field_scan8x8; | |
4707 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4708 } |
1168 | 4709 |
4710 alloc_tables(h); | |
4711 | |
4712 s->avctx->width = s->width; | |
4713 s->avctx->height = s->height; | |
1548 | 4714 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4715 if(!s->avctx->sample_aspect_ratio.den) |
4716 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
|
4717 |
2648 | 4718 if(h->sps.timing_info_present_flag){ |
3052 | 4719 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
|
4720 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
|
4721 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4722 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
|
4723 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
|
4724 } |
1168 | 4725 } |
4726 | |
2392 | 4727 if(h->slice_num == 0){ |
2935 | 4728 if(frame_start(h) < 0) |
4729 return -1; | |
1168 | 4730 } |
4731 | |
1169 | 4732 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4733 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4734 | |
3316 | 4735 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4736 h->mb_aff_frame = 0; |
1168 | 4737 if(h->sps.frame_mbs_only_flag){ |
4738 s->picture_structure= PICT_FRAME; | |
4739 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4740 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4741 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4742 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
|
4743 } else { |
1168 | 4744 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4745 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
|
4746 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4747 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4748 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4749 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4750 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame; |
2772 | 4751 if(s->mb_y >= s->mb_height){ |
4752 return -1; | |
4753 } | |
2967 | 4754 |
1168 | 4755 if(s->picture_structure==PICT_FRAME){ |
4756 h->curr_pic_num= h->frame_num; | |
4757 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4758 }else{ | |
4759 h->curr_pic_num= 2*h->frame_num; | |
4760 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4761 } | |
2967 | 4762 |
1168 | 4763 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4764 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4765 } |
2967 | 4766 |
1168 | 4767 if(h->sps.poc_type==0){ |
4768 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4769 |
1168 | 4770 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4771 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4772 } | |
4773 } | |
2967 | 4774 |
1168 | 4775 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4776 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4777 |
1168 | 4778 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4779 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4780 } | |
2967 | 4781 |
1168 | 4782 init_poc(h); |
2967 | 4783 |
1168 | 4784 if(h->pps.redundant_pic_cnt_present){ |
4785 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4786 } | |
4787 | |
4788 //set defaults, might be overriden a few line later | |
4789 h->ref_count[0]= h->pps.ref_count[0]; | |
4790 h->ref_count[1]= h->pps.ref_count[1]; | |
4791 | |
4792 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4793 if(h->slice_type == B_TYPE){ | |
4794 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4795 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4796 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4797 } |
4798 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4799 |
1168 | 4800 if(num_ref_idx_active_override_flag){ |
4801 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4802 if(h->slice_type==B_TYPE) | |
4803 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4804 | |
4805 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
|
4806 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
1168 | 4807 return -1; |
4808 } | |
4809 } | |
4810 } | |
4811 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4812 if(!default_ref_list_done){ |
1168 | 4813 fill_default_ref_list(h); |
4814 } | |
4815 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4816 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
|
4817 return -1; |
1168 | 4818 |
2967 | 4819 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4820 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4821 pred_weight_table(h); | |
2415 | 4822 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4823 implicit_weight_table(h); | |
4824 else | |
4825 h->use_weight = 0; | |
2967 | 4826 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4827 if(s->current_picture.reference) |
1168 | 4828 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
|
4829 |
3316 | 4830 if(FRAME_MBAFF) |
4831 fill_mbaff_ref_list(h); | |
4832 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4833 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
|
4834 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
|
4835 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4836 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
|
4837 s->qscale = h->pps.init_qp + get_se_golomb(&s->gb); |
1898 | 4838 if(s->qscale<0 || s->qscale>51){ |
4839 av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale); | |
4840 return -1; | |
4841 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4842 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4843 //FIXME qscale / qp ... stuff |
4844 if(h->slice_type == SP_TYPE){ | |
1453 | 4845 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4846 } |
4847 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4848 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4849 } |
4850 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4851 h->deblocking_filter = 1; |
1898 | 4852 h->slice_alpha_c0_offset = 0; |
4853 h->slice_beta_offset = 0; | |
1168 | 4854 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
|
4855 h->deblocking_filter= get_ue_golomb(&s->gb); |
2967 | 4856 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
|
4857 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
|
4858 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4859 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
|
4860 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
|
4861 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4862 } |
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
|
4863 } |
2792 | 4864 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4865 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4866 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4867 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4868 h->deblocking_filter= 0; | |
1168 | 4869 |
4870 #if 0 //FMO | |
4871 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4872 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4873 #endif | |
4874 | |
2392 | 4875 h->slice_num++; |
4876 | |
3316 | 4877 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4878 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4879 | |
1168 | 4880 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 4881 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n", |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4882 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4883 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4884 first_mb_in_slice, |
1264 | 4885 av_get_pict_type_char(h->slice_type), |
1168 | 4886 pps_id, h->frame_num, |
4887 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4888 h->ref_count[0], h->ref_count[1], | |
4889 s->qscale, | |
2583 | 4890 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4891 h->use_weight, |
4892 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4893 ); |
4894 } | |
4895 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4896 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
|
4897 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
|
4898 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
|
4899 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4900 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
|
4901 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
|
4902 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4903 |
1168 | 4904 return 0; |
4905 } | |
4906 | |
4907 /** | |
4908 * | |
4909 */ | |
4910 static inline int get_level_prefix(GetBitContext *gb){ | |
4911 unsigned int buf; | |
4912 int log; | |
2967 | 4913 |
1168 | 4914 OPEN_READER(re, gb); |
4915 UPDATE_CACHE(re, gb); | |
4916 buf=GET_CACHE(re, gb); | |
2967 | 4917 |
1168 | 4918 log= 32 - av_log2(buf); |
4919 #ifdef TRACE | |
4920 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
|
4921 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 | 4922 #endif |
4923 | |
4924 LAST_SKIP_BITS(re, gb, log); | |
4925 CLOSE_READER(re, gb); | |
4926 | |
4927 return log-1; | |
4928 } | |
4929 | |
2755 | 4930 static inline int get_dct8x8_allowed(H264Context *h){ |
4931 int i; | |
4932 for(i=0; i<4; i++){ | |
4933 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
|
4934 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4935 return 0; |
4936 } | |
4937 return 1; | |
4938 } | |
4939 | |
1168 | 4940 /** |
4941 * decodes a residual block. | |
4942 * @param n block index | |
4943 * @param scantable scantable | |
4944 * @param max_coeff number of coefficients in the block | |
4945 * @return <0 if an error occured | |
4946 */ | |
2919 | 4947 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4948 MpegEncContext * const s = &h->s; |
4949 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 | 4950 int level[16]; |
4951 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4952 |
4953 //FIXME put trailing_onex into the context | |
4954 | |
4955 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4956 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4957 total_coeff= coeff_token>>2; | |
2967 | 4958 }else{ |
1168 | 4959 if(n == LUMA_DC_BLOCK_INDEX){ |
4960 total_coeff= pred_non_zero_count(h, 0); | |
4961 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4962 total_coeff= coeff_token>>2; | |
4963 }else{ | |
4964 total_coeff= pred_non_zero_count(h, n); | |
4965 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4966 total_coeff= coeff_token>>2; | |
4967 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4968 } | |
4969 } | |
4970 | |
4971 //FIXME set last_non_zero? | |
4972 | |
4973 if(total_coeff==0) | |
4974 return 0; | |
2967 | 4975 |
1168 | 4976 trailing_ones= coeff_token&3; |
1170 | 4977 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4978 assert(total_coeff<=16); |
2967 | 4979 |
1168 | 4980 for(i=0; i<trailing_ones; i++){ |
4981 level[i]= 1 - 2*get_bits1(gb); | |
4982 } | |
4983 | |
2897 | 4984 if(i<total_coeff) { |
1168 | 4985 int level_code, mask; |
2897 | 4986 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4987 int prefix= get_level_prefix(gb); | |
4988 | |
4989 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4990 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4991 if(suffix_length) | |
4992 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4993 else | |
4994 level_code= (prefix<<suffix_length); //part | |
4995 }else if(prefix==14){ | |
4996 if(suffix_length) | |
4997 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4998 else | |
4999 level_code= prefix + get_bits(gb, 4); //part | |
5000 }else if(prefix==15){ | |
5001 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
|
5002 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 5003 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5004 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 5005 return -1; |
5006 } | |
5007 | |
2897 | 5008 if(trailing_ones < 3) level_code += 2; |
5009 | |
5010 suffix_length = 1; | |
5011 if(level_code > 5) | |
5012 suffix_length++; | |
1168 | 5013 mask= -(level_code&1); |
5014 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 5015 i++; |
5016 | |
5017 //remaining coefficients have suffix_length > 0 | |
5018 for(;i<total_coeff;i++) { | |
5019 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
5020 prefix = get_level_prefix(gb); | |
5021 if(prefix<15){ | |
5022 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
5023 }else if(prefix==15){ | |
5024 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
5025 }else{ | |
5026 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
5027 return -1; | |
5028 } | |
5029 mask= -(level_code&1); | |
5030 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
5031 if(level_code > suffix_limit[suffix_length]) | |
5032 suffix_length++; | |
5033 } | |
1168 | 5034 } |
5035 | |
5036 if(total_coeff == max_coeff) | |
5037 zeros_left=0; | |
5038 else{ | |
5039 if(n == CHROMA_DC_BLOCK_INDEX) | |
5040 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
5041 else | |
5042 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
5043 } | |
2897 | 5044 |
5045 coeff_num = zeros_left + total_coeff - 1; | |
5046 j = scantable[coeff_num]; | |
5047 if(n > 24){ | |
5048 block[j] = level[0]; | |
5049 for(i=1;i<total_coeff;i++) { | |
5050 if(zeros_left <= 0) | |
5051 run_before = 0; | |
5052 else if(zeros_left < 7){ | |
5053 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
5054 }else{ | |
5055 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
5056 } | |
5057 zeros_left -= run_before; | |
5058 coeff_num -= 1 + run_before; | |
5059 j= scantable[ coeff_num ]; | |
5060 | |
5061 block[j]= level[i]; | |
5062 } | |
5063 }else{ | |
2919 | 5064 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 5065 for(i=1;i<total_coeff;i++) { |
5066 if(zeros_left <= 0) | |
5067 run_before = 0; | |
5068 else if(zeros_left < 7){ | |
5069 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
5070 }else{ | |
5071 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
5072 } | |
5073 zeros_left -= run_before; | |
5074 coeff_num -= 1 + run_before; | |
5075 j= scantable[ coeff_num ]; | |
5076 | |
2919 | 5077 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 5078 } |
1168 | 5079 } |
5080 | |
5081 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5082 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 5083 return -1; |
5084 } | |
2897 | 5085 |
1168 | 5086 return 0; |
5087 } | |
5088 | |
3316 | 5089 static void predict_field_decoding_flag(H264Context *h){ |
5090 MpegEncContext * const s = &h->s; | |
5091 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
5092 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
5093 ? s->current_picture.mb_type[mb_xy-1] | |
5094 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
5095 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
5096 : 0; | |
5097 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
5098 } | |
5099 | |
1168 | 5100 /** |
2396 | 5101 * decodes a P_SKIP or B_SKIP macroblock |
5102 */ | |
5103 static void decode_mb_skip(H264Context *h){ | |
5104 MpegEncContext * const s = &h->s; | |
5105 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
|
5106 int mb_type=0; |
2967 | 5107 |
2396 | 5108 memset(h->non_zero_count[mb_xy], 0, 16); |
5109 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
5110 | |
3316 | 5111 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5112 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5113 |
2396 | 5114 if( h->slice_type == B_TYPE ) |
5115 { | |
5116 // 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
|
5117 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5118 |
2449 | 5119 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5120 pred_direct_motion(h, &mb_type); |
3927 | 5121 mb_type|= MB_TYPE_SKIP; |
2396 | 5122 } |
5123 else | |
5124 { | |
5125 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5126 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5127 |
2449 | 5128 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5129 pred_pskip_motion(h, &mx, &my); |
5130 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5131 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5132 } | |
5133 | |
5134 write_back_motion(h, mb_type); | |
3927 | 5135 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5136 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5137 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
|
5138 h->prev_mb_skipped= 1; |
2396 | 5139 } |
5140 | |
5141 /** | |
1168 | 5142 * decodes a macroblock |
5143 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5144 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5145 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5146 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
|
5147 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1169 | 5148 int mb_type, partition_count, cbp; |
2755 | 5149 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5150 |
2967 | 5151 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5152 |
1170 | 5153 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5154 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5155 down the code */ | |
1168 | 5156 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5157 if(s->mb_skip_run==-1) | |
5158 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5159 |
1168 | 5160 if (s->mb_skip_run--) { |
3316 | 5161 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5162 if(s->mb_skip_run==0) | |
5163 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5164 else | |
5165 predict_field_decoding_flag(h); | |
5166 } | |
2396 | 5167 decode_mb_skip(h); |
1168 | 5168 return 0; |
5169 } | |
5170 } | |
3316 | 5171 if(FRAME_MBAFF){ |
5172 if( (s->mb_y&1) == 0 ) | |
5173 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5174 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5175 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5176 |
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
|
5177 h->prev_mb_skipped= 0; |
2967 | 5178 |
1168 | 5179 mb_type= get_ue_golomb(&s->gb); |
5180 if(h->slice_type == B_TYPE){ | |
5181 if(mb_type < 23){ | |
5182 partition_count= b_mb_type_info[mb_type].partition_count; | |
5183 mb_type= b_mb_type_info[mb_type].type; | |
5184 }else{ | |
5185 mb_type -= 23; | |
5186 goto decode_intra_mb; | |
5187 } | |
5188 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5189 if(mb_type < 5){ | |
5190 partition_count= p_mb_type_info[mb_type].partition_count; | |
5191 mb_type= p_mb_type_info[mb_type].type; | |
5192 }else{ | |
5193 mb_type -= 5; | |
5194 goto decode_intra_mb; | |
5195 } | |
5196 }else{ | |
5197 assert(h->slice_type == I_TYPE); | |
5198 decode_intra_mb: | |
5199 if(mb_type > 25){ | |
3954 | 5200 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 | 5201 return -1; |
5202 } | |
5203 partition_count=0; | |
5204 cbp= i_mb_type_info[mb_type].cbp; | |
5205 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5206 mb_type= i_mb_type_info[mb_type].type; | |
5207 } | |
5208 | |
3316 | 5209 if(MB_FIELD) |
1168 | 5210 mb_type |= MB_TYPE_INTERLACED; |
5211 | |
5212 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5213 |
1168 | 5214 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5215 unsigned int x, y; |
2967 | 5216 |
1168 | 5217 // we assume these blocks are very rare so we dont optimize it |
5218 align_get_bits(&s->gb); | |
2967 | 5219 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5220 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5221 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5222 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5223 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5224 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
|
5225 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5226 } |
5227 } | |
5228 for(y=0; y<8; y++){ | |
5229 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5230 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5231 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
|
5232 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5233 } |
5234 } | |
5235 for(y=0; y<8; y++){ | |
5236 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5237 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5238 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
|
5239 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5240 } |
5241 } | |
2967 | 5242 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5243 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5244 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
|
5245 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
|
5246 // 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
|
5247 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5248 |
2755 | 5249 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5250 return 0; |
5251 } | |
2967 | 5252 |
3316 | 5253 if(MB_MBAFF){ |
5254 h->ref_count[0] <<= 1; | |
5255 h->ref_count[1] <<= 1; | |
5256 } | |
5257 | |
2449 | 5258 fill_caches(h, mb_type, 0); |
1168 | 5259 |
5260 //mb_pred | |
5261 if(IS_INTRA(mb_type)){ | |
5262 // init_top_left_availability(h); | |
5263 if(IS_INTRA4x4(mb_type)){ | |
5264 int i; | |
2755 | 5265 int di = 1; |
5266 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5267 mb_type |= MB_TYPE_8x8DCT; | |
5268 di = 4; | |
5269 } | |
1168 | 5270 |
5271 // fill_intra4x4_pred_table(h); | |
2755 | 5272 for(i=0; i<16; i+=di){ |
3409 | 5273 int mode= pred_intra_mode(h, i); |
5274 | |
5275 if(!get_bits1(&s->gb)){ | |
1168 | 5276 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5277 mode = rem_mode + (rem_mode >= mode); |
1168 | 5278 } |
2967 | 5279 |
2755 | 5280 if(di==4) |
5281 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5282 else | |
5283 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5284 } |
5285 write_back_intra_pred_mode(h); | |
5286 if( check_intra4x4_pred_mode(h) < 0) | |
5287 return -1; | |
5288 }else{ | |
5289 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5290 if(h->intra16x16_pred_mode < 0) | |
5291 return -1; | |
5292 } | |
5293 h->chroma_pred_mode= get_ue_golomb(&s->gb); | |
5294 | |
5295 h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode); | |
5296 if(h->chroma_pred_mode < 0) | |
5297 return -1; | |
5298 }else if(partition_count==4){ | |
5299 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5300 |
1168 | 5301 if(h->slice_type == B_TYPE){ |
5302 for(i=0; i<4; i++){ | |
5303 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5304 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
|
5305 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 | 5306 return -1; |
5307 } | |
5308 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5309 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5310 } | |
2396 | 5311 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5312 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5313 pred_direct_motion(h, &mb_type); |
3003 | 5314 h->ref_cache[0][scan8[4]] = |
5315 h->ref_cache[1][scan8[4]] = | |
5316 h->ref_cache[0][scan8[12]] = | |
5317 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5318 } | |
1168 | 5319 }else{ |
5320 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5321 for(i=0; i<4; i++){ | |
5322 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5323 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
|
5324 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 | 5325 return -1; |
5326 } | |
5327 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5328 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5329 } | |
5330 } | |
2967 | 5331 |
1168 | 5332 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
|
5333 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5334 if(ref_count == 0) continue; |
5335 for(i=0; i<4; i++){ | |
2396 | 5336 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5337 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1168 | 5338 ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
5339 }else{ | |
5340 //FIXME | |
5341 ref[list][i] = -1; | |
5342 } | |
5343 } | |
5344 } | |
2967 | 5345 |
2755 | 5346 if(dct8x8_allowed) |
5347 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5348 |
1168 | 5349 for(list=0; list<2; list++){ |
5350 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
5351 if(ref_count == 0) continue; | |
5352 | |
5353 for(i=0; i<4; i++){ | |
3003 | 5354 if(IS_DIRECT(h->sub_mb_type[i])) { |
5355 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5356 continue; | |
5357 } | |
1168 | 5358 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5359 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5360 | |
2396 | 5361 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5362 const int sub_mb_type= h->sub_mb_type[i]; |
5363 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5364 for(j=0; j<sub_partition_count[i]; j++){ | |
5365 int mx, my; | |
5366 const int index= 4*i + block_width*j; | |
5367 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5368 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5369 mx += get_se_golomb(&s->gb); | |
5370 my += get_se_golomb(&s->gb); | |
1170 | 5371 tprintf("final mv:%d %d\n", mx, my); |
5372 | |
1168 | 5373 if(IS_SUB_8X8(sub_mb_type)){ |
2967 | 5374 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
1168 | 5375 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
2967 | 5376 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
1168 | 5377 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5378 }else if(IS_SUB_8X4(sub_mb_type)){ | |
5379 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; | |
5380 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; | |
5381 }else if(IS_SUB_4X8(sub_mb_type)){ | |
5382 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; | |
5383 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; | |
5384 }else{ | |
5385 assert(IS_SUB_4X4(sub_mb_type)); | |
5386 mv_cache[ 0 ][0]= mx; | |
5387 mv_cache[ 0 ][1]= my; | |
5388 } | |
5389 } | |
5390 }else{ | |
5391 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5392 p[0] = p[1]= | |
5393 p[8] = p[9]= 0; | |
5394 } | |
5395 } | |
5396 } | |
2396 | 5397 }else if(IS_DIRECT(mb_type)){ |
5398 pred_direct_motion(h, &mb_type); | |
2755 | 5399 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5400 }else{ |
1168 | 5401 int list, mx, my, i; |
5402 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5403 if(IS_16X16(mb_type)){ | |
5404 for(list=0; list<2; list++){ | |
2392 | 5405 if(h->ref_count[list]>0){ |
1168 | 5406 if(IS_DIR(mb_type, 0, list)){ |
5407 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5408 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
2523 | 5409 }else |
5410 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 5411 } |
5412 } | |
5413 for(list=0; list<2; list++){ | |
5414 if(IS_DIR(mb_type, 0, list)){ | |
5415 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5416 mx += get_se_golomb(&s->gb); | |
5417 my += get_se_golomb(&s->gb); | |
1170 | 5418 tprintf("final mv:%d %d\n", mx, my); |
5419 | |
1269 | 5420 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5421 }else |
5422 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1168 | 5423 } |
5424 } | |
5425 else if(IS_16X8(mb_type)){ | |
5426 for(list=0; list<2; list++){ | |
5427 if(h->ref_count[list]>0){ | |
5428 for(i=0; i<2; i++){ | |
5429 if(IS_DIR(mb_type, i, list)){ | |
5430 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5431 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
2523 | 5432 }else |
2396 | 5433 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5434 } |
5435 } | |
5436 } | |
5437 for(list=0; list<2; list++){ | |
5438 for(i=0; i<2; i++){ | |
5439 if(IS_DIR(mb_type, i, list)){ | |
5440 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5441 mx += get_se_golomb(&s->gb); | |
5442 my += get_se_golomb(&s->gb); | |
1170 | 5443 tprintf("final mv:%d %d\n", mx, my); |
5444 | |
1269 | 5445 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5446 }else |
5447 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 5448 } |
5449 } | |
5450 }else{ | |
5451 assert(IS_8X16(mb_type)); | |
5452 for(list=0; list<2; list++){ | |
5453 if(h->ref_count[list]>0){ | |
5454 for(i=0; i<2; i++){ | |
5455 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
5456 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5457 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
2523 | 5458 }else |
2396 | 5459 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5460 } |
5461 } | |
5462 } | |
5463 for(list=0; list<2; list++){ | |
5464 for(i=0; i<2; i++){ | |
5465 if(IS_DIR(mb_type, i, list)){ | |
5466 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5467 mx += get_se_golomb(&s->gb); | |
5468 my += get_se_golomb(&s->gb); | |
1170 | 5469 tprintf("final mv:%d %d\n", mx, my); |
5470 | |
1269 | 5471 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5472 }else |
5473 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 5474 } |
5475 } | |
5476 } | |
5477 } | |
2967 | 5478 |
1168 | 5479 if(IS_INTER(mb_type)) |
5480 write_back_motion(h, mb_type); | |
2967 | 5481 |
1168 | 5482 if(!IS_INTRA16x16(mb_type)){ |
5483 cbp= get_ue_golomb(&s->gb); | |
5484 if(cbp > 47){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5485 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5486 return -1; |
5487 } | |
2967 | 5488 |
1168 | 5489 if(IS_INTRA4x4(mb_type)) |
5490 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5491 else | |
5492 cbp= golomb_to_inter_cbp[cbp]; | |
5493 } | |
3651 | 5494 h->cbp = cbp; |
1168 | 5495 |
2755 | 5496 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5497 if(get_bits1(&s->gb)) | |
5498 mb_type |= MB_TYPE_8x8DCT; | |
5499 } | |
5500 s->current_picture.mb_type[mb_xy]= mb_type; | |
5501 | |
1168 | 5502 if(cbp || IS_INTRA16x16(mb_type)){ |
5503 int i8x8, i4x4, chroma_idx; | |
5504 int chroma_qp, dquant; | |
5505 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5506 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5507 |
1168 | 5508 // fill_non_zero_count_cache(h); |
5509 | |
5510 if(IS_INTERLACED(mb_type)){ | |
3316 | 5511 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5512 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5513 dc_scan= luma_dc_field_scan; |
5514 }else{ | |
3316 | 5515 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5516 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5517 dc_scan= luma_dc_zigzag_scan; |
5518 } | |
5519 | |
5520 dquant= get_se_golomb(&s->gb); | |
5521 | |
5522 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5523 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 | 5524 return -1; |
5525 } | |
2967 | 5526 |
1168 | 5527 s->qscale += dquant; |
5528 if(((unsigned)s->qscale) > 51){ | |
5529 if(s->qscale<0) s->qscale+= 52; | |
5530 else s->qscale-= 52; | |
5531 } | |
2967 | 5532 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5533 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5534 if(IS_INTRA16x16(mb_type)){ |
2919 | 5535 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
|
5536 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5537 } |
5538 | |
5539 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5540 | |
5541 if(cbp&15){ | |
5542 for(i8x8=0; i8x8<4; i8x8++){ | |
5543 for(i4x4=0; i4x4<4; i4x4++){ | |
5544 const int index= i4x4 + 4*i8x8; | |
2919 | 5545 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5546 return -1; |
5547 } | |
5548 } | |
5549 } | |
5550 }else{ | |
1636 | 5551 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5552 } |
5553 }else{ | |
5554 for(i8x8=0; i8x8<4; i8x8++){ | |
5555 if(cbp & (1<<i8x8)){ | |
2755 | 5556 if(IS_8x8DCT(mb_type)){ |
5557 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5558 uint8_t *nnz; |
2755 | 5559 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5560 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5561 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5562 return -1; |
5563 } | |
2757 | 5564 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
|
5565 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5566 }else{ |
5567 for(i4x4=0; i4x4<4; i4x4++){ | |
5568 const int index= i4x4 + 4*i8x8; | |
2967 | 5569 |
2919 | 5570 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 | 5571 return -1; |
5572 } | |
1168 | 5573 } |
5574 } | |
5575 }else{ | |
5576 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5577 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5578 } | |
5579 } | |
5580 } | |
2967 | 5581 |
1168 | 5582 if(cbp&0x30){ |
5583 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5584 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5585 return -1; |
5586 } | |
5587 } | |
5588 | |
5589 if(cbp&0x20){ | |
5590 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5591 for(i4x4=0; i4x4<4; i4x4++){ | |
5592 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5593 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 | 5594 return -1; |
5595 } | |
5596 } | |
5597 } | |
5598 }else{ | |
5599 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5600 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5601 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5602 } | |
5603 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5604 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
|
5605 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
|
5606 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
|
5607 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5608 } |
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
|
5609 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5610 write_back_non_zero_count(h); |
5611 | |
3316 | 5612 if(MB_MBAFF){ |
5613 h->ref_count[0] >>= 1; | |
5614 h->ref_count[1] >>= 1; | |
5615 } | |
5616 | |
1168 | 5617 return 0; |
5618 } | |
5619 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5620 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
|
5621 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
|
5622 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
|
5623 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
|
5624 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
|
5625 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
|
5626 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5627 unsigned int ctx = 0; |
2967 | 5628 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5629 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
|
5630 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5631 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5632 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
|
5633 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5634 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5635 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5636 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
|
5637 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5638 |
2312 | 5639 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5640 uint8_t *state= &h->cabac_state[ctx_base]; | |
5641 int mb_type; | |
2967 | 5642 |
2312 | 5643 if(intra_slice){ |
5644 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
|
5645 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
|
5646 const int mbb_xy = h->top_mb_xy; |
2312 | 5647 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5648 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
|
5649 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5650 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
|
5651 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5652 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5653 return 0; /* I4x4 */ |
5654 state += 2; | |
5655 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5656 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
|
5657 return 0; /* I4x4 */ |
2312 | 5658 } |
5659 | |
5660 if( get_cabac_terminate( &h->cabac ) ) | |
5661 return 25; /* PCM */ | |
5662 | |
5663 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
|
5664 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
|
5665 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
|
5666 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
|
5667 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
|
5668 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5669 return mb_type; |
5670 } | |
5671 | |
5672 static int decode_cabac_mb_type( H264Context *h ) { | |
5673 MpegEncContext * const s = &h->s; | |
5674 | |
5675 if( h->slice_type == I_TYPE ) { | |
5676 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
|
5677 } 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
|
5678 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
|
5679 /* 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
|
5680 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5681 /* 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
|
5682 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
|
5683 } else { |
3138 | 5684 /* 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
|
5685 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
|
5686 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5687 } else { |
2312 | 5688 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
|
5689 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5690 } 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
|
5691 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
|
5692 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
|
5693 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
|
5694 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5695 |
3138 | 5696 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
|
5697 ctx++; |
3138 | 5698 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
|
5699 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5700 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5701 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
|
5702 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
|
5703 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5704 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
|
5705 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
|
5706 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5707 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5708 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
|
5709 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
|
5710 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
|
5711 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
|
5712 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
|
5713 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
|
5714 else if( bits == 13 ) { |
2312 | 5715 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
|
5716 } 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
|
5717 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
|
5718 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
|
5719 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
|
5720 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5721 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
|
5722 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
|
5723 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5724 /* 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
|
5725 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
|
5726 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5727 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5728 |
3316 | 5729 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
|
5730 MpegEncContext * const s = &h->s; |
3316 | 5731 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
|
5732 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
|
5733 |
3316 | 5734 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5735 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5736 mba_xy = mb_xy - 1; | |
5737 if( (mb_y&1) | |
5738 && h->slice_table[mba_xy] == h->slice_num | |
5739 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5740 mba_xy += s->mb_stride; | |
5741 if( MB_FIELD ){ | |
5742 mbb_xy = mb_xy - s->mb_stride; | |
5743 if( !(mb_y&1) | |
5744 && h->slice_table[mbb_xy] == h->slice_num | |
5745 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5746 mbb_xy -= s->mb_stride; | |
5747 }else | |
5748 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5749 }else{ | |
5750 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5751 mba_xy = mb_xy - 1; | |
5752 mbb_xy = mb_xy - s->mb_stride; | |
5753 } | |
5754 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5755 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
|
5756 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5757 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
|
5758 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5759 |
3138 | 5760 if( h->slice_type == B_TYPE ) |
5761 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
|
5762 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
|
5763 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5764 |
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_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
|
5766 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
|
5767 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5768 if( 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
|
5769 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
|
5770 |
2928 | 5771 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5772 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5773 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5774 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5775 if( 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
|
5776 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
|
5777 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5778 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
|
5779 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5780 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5781 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
|
5782 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
|
5783 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
|
5784 |
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 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
|
5786 |
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
|
5787 /* 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
|
5788 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
|
5789 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
|
5790 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5791 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
|
5792 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5793 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5794 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
|
5795 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
|
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 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
|
5798 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
|
5799 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
|
5800 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
|
5801 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5802 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
|
5803 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5804 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5805 static 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
|
5806 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
|
5807 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5808 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
|
5809 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
|
5810 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5811 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
|
5812 { 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
|
5813 { 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
|
5814 { 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
|
5815 { 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
|
5816 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5817 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5818 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
|
5819 int cbp = 0; |
3138 | 5820 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
|
5821 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
|
5822 |
3138 | 5823 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5824 cbp_b = h->top_cbp; | |
5825 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5826 } | |
5827 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5828 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
|
5829 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
|
5830 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
|
5831 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5832 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5833 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
|
5834 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
|
5835 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5836 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
|
5837 cbp_a = cbp; |
3138 | 5838 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
|
5839 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
|
5840 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
|
5841 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5842 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5843 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
|
5844 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
|
5845 |
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
|
5846 /* 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
|
5847 /* 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
|
5848 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
|
5849 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
|
5850 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
|
5851 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5852 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5853 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5854 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
|
5855 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
|
5856 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
|
5857 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
|
5858 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5859 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5860 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
|
5861 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
|
5862 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5863 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5864 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
|
5865 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5866 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
|
5867 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
|
5868 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
|
5869 |
2314 | 5870 cbp_a = (h->left_cbp>>4)&0x03; |
5871 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
|
5872 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5873 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
|
5874 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
|
5875 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
|
5876 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
|
5877 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
|
5878 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5879 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
|
5880 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
|
5881 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
|
5882 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
|
5883 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5884 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
|
5885 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
|
5886 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
|
5887 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
|
5888 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
|
5889 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5890 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
|
5891 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
|
5892 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5893 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
|
5894 |
3316 | 5895 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
|
5896 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5897 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5898 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
|
5899 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
|
5900 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
|
5901 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5902 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
|
5903 val++; |
3128 | 5904 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5905 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
|
5906 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5907 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5908 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
|
5909 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
|
5910 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5911 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
|
5912 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5913 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
|
5914 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
|
5915 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
|
5916 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
|
5917 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
|
5918 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
|
5919 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
|
5920 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
|
5921 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5922 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
|
5923 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5924 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
|
5925 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
|
5926 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
|
5927 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
|
5928 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5929 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
|
5930 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
|
5931 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
|
5932 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5933 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5934 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
|
5935 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
|
5936 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5937 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5938 |
2755 | 5939 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
|
5940 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5941 } |
5942 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5943 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
|
5944 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
|
5945 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
|
5946 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
|
5947 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
|
5948 |
2396 | 5949 if( h->slice_type == B_TYPE) { |
5950 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5951 ctx++; | |
5952 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5953 ctx += 2; | |
5954 } else { | |
5955 if( refa > 0 ) | |
5956 ctx++; | |
5957 if( refb > 0 ) | |
5958 ctx += 2; | |
5959 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5960 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5961 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
|
5962 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5963 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
|
5964 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5965 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5966 ctx = 5; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5967 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5968 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5969 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5970 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5971 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
|
5972 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
|
5973 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
|
5974 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5975 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
|
5976 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5977 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
|
5978 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5979 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
|
5980 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5981 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5982 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5983 |
2317 | 5984 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5985 return 0; | |
5986 | |
5987 mvd= 1; | |
5988 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
|
5989 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
|
5990 mvd++; |
2317 | 5991 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
|
5992 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5993 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5994 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5995 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
|
5996 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
|
5997 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
|
5998 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
|
5999 k++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6000 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6001 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6002 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
|
6003 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
|
6004 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6005 } |
2317 | 6006 if( get_cabac_bypass( &h->cabac ) ) return -mvd; |
6007 else return mvd; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6008 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6009 |
2316 | 6010 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 6011 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
|
6012 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
|
6013 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6014 if( cat == 0 ) { |
2314 | 6015 nza = h->left_cbp&0x100; |
6016 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
|
6017 } else if( cat == 1 || cat == 2 ) { |
2314 | 6018 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
6019 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
|
6020 } else if( cat == 3 ) { |
2314 | 6021 nza = (h->left_cbp>>(6+idx))&0x01; |
6022 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
6023 } else { | |
6024 assert(cat == 4); | |
6025 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
6026 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
6027 } | |
6028 | |
6029 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
|
6030 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6031 |
2314 | 6032 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
|
6033 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
|
6034 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6035 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
|
6036 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6037 |
3028 | 6038 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
|
6039 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 6040 static const int significant_coeff_flag_offset[2][6] = { |
6041 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
6042 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
6043 }; | |
6044 static const int last_coeff_flag_offset[2][6] = { | |
6045 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
6046 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
6047 }; | |
6048 static const int coeff_abs_level_m1_offset[6] = { | |
6049 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
6050 }; | |
4007 | 6051 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 6052 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 6053 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
6054 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 6055 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
6056 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
6057 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
6058 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
6059 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 6060 }; |
4007 | 6061 static const uint8_t last_coeff_flag_offset_8x8[63] = { |
2755 | 6062 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
6063 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
6064 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
6065 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
6066 }; | |
6067 | |
6068 int index[64]; | |
2313 | 6069 |
6070 int i, 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
|
6071 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
|
6072 |
2316 | 6073 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
|
6074 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
|
6075 |
2898 | 6076 uint8_t *significant_coeff_ctx_base; |
6077 uint8_t *last_coeff_ctx_base; | |
6078 uint8_t *abs_level_m1_ctx_base; | |
2755 | 6079 |
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
|
6080 #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
|
6081 #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
|
6082 #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
|
6083 #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
|
6084 #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
|
6085 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
|
6086 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
|
6087 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
|
6088 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
|
6089 #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
|
6090 #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
|
6091 #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
|
6092 |
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 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6094 /* 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
|
6095 * 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
|
6096 * 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
|
6097 * 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
|
6098 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 6099 * 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
|
6100 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6101 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6102 /* read coded block flag */ |
2898 | 6103 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
|
6104 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 6105 if( cat == 1 || cat == 2 ) |
6106 h->non_zero_count_cache[scan8[n]] = 0; | |
6107 else if( cat == 4 ) | |
6108 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
|
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 |
2755 | 6114 return 0; |
6115 } | |
2898 | 6116 } |
6117 | |
6118 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6119 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6120 last_coeff_ctx_base = h->cabac_state |
3316 | 6121 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6122 abs_level_m1_ctx_base = h->cabac_state |
6123 + coeff_abs_level_m1_offset[cat]; | |
6124 | |
6125 if( cat == 5 ) { | |
6126 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6127 for(last= 0; last < coefs; last++) { \ | |
6128 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
|
6129 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6130 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6131 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
|
6132 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6133 last= max_coeff; \ |
6134 break; \ | |
6135 } \ | |
6136 } \ | |
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
|
6137 }\ |
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
|
6138 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
|
6139 index[coeff_count++] = last;\ |
2898 | 6140 } |
4009 | 6141 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; |
3316 | 6142 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6143 } else { |
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
|
6144 #ifdef ARCH_X86 |
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
|
6145 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); |
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
|
6146 #else |
2898 | 6147 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
|
6148 #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
|
6149 } |
2316 | 6150 assert(coeff_count > 0); |
6151 | |
6152 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
|
6153 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
|
6154 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
|
6155 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6156 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
|
6157 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6158 else if( cat == 4 ) |
6159 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6160 else { |
2755 | 6161 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6162 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6163 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6164 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6165 for( i = coeff_count - 1; i >= 0; i-- ) { |
2898 | 6166 uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base; |
2316 | 6167 int j= scantable[index[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
|
6168 |
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
|
6169 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6170 if( !qmul ) { |
4040 | 6171 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6172 }else{ |
4040 | 6173 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6174 } |
2967 | 6175 |
2313 | 6176 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
|
6177 } else { |
2313 | 6178 int coeff_abs = 2; |
2898 | 6179 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
|
6180 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6181 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
|
6182 } |
2313 | 6183 |
6184 if( coeff_abs >= 15 ) { | |
6185 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
|
6186 while( get_cabac_bypass( CC ) ) { |
2313 | 6187 j++; |
6188 } | |
2967 | 6189 |
4016 | 6190 coeff_abs=1; |
2313 | 6191 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
|
6192 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6193 } |
4016 | 6194 coeff_abs+= 14; |
2313 | 6195 } |
6196 | |
2898 | 6197 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
|
6198 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6199 else block[j] = coeff_abs; |
6200 }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
|
6201 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6202 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6203 } |
2967 | 6204 |
2313 | 6205 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
|
6206 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6207 } |
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
|
6208 #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
|
6209 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
|
6210 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
|
6211 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
|
6212 #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
|
6213 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
|
6214 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6215 |
3077 | 6216 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
|
6217 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6218 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
|
6219 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
|
6220 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
|
6221 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6222 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
|
6223 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
|
6224 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
|
6225 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
|
6226 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6227 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
|
6228 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
|
6229 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6230 ? !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
|
6231 : (!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
|
6232 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6233 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
|
6234 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6235 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
|
6236 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
|
6237 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6238 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6239 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6240 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6241 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6242 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6243 * 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
|
6244 * @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
|
6245 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6246 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
|
6247 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
|
6248 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
|
6249 int mb_type, partition_count, cbp = 0; |
2755 | 6250 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
|
6251 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6252 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
|
6253 |
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
|
6254 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
|
6255 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6256 int skip; |
6257 /* a skipped mb needs the aff flag from the following mb */ | |
6258 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6259 predict_field_decoding_flag(h); | |
6260 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6261 skip = h->next_mb_skipped; | |
6262 else | |
6263 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
|
6264 /* read skip flags */ |
3316 | 6265 if( skip ) { |
6266 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6267 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6268 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6269 if(h->next_mb_skipped) | |
6270 predict_field_decoding_flag(h); | |
6271 else | |
6272 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6273 } | |
6274 | |
2396 | 6275 decode_mb_skip(h); |
6276 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6277 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
|
6278 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
|
6279 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
|
6280 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6281 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
|
6282 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6283 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6284 } |
3316 | 6285 if(FRAME_MBAFF){ |
6286 if( (s->mb_y&1) == 0 ) | |
6287 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
|
6288 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
|
6289 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6290 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
|
6291 |
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
|
6292 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
|
6293 |
3077 | 6294 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
|
6295 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
|
6296 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
|
6297 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
|
6298 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6299 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6300 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
|
6301 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
|
6302 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
|
6303 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
|
6304 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6305 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
|
6306 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
|
6307 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6308 } 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
|
6309 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
|
6310 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
|
6311 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
|
6312 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6313 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
|
6314 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
|
6315 } |
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 { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6317 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
|
6318 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
|
6319 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
|
6320 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
|
6321 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
|
6322 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
|
6323 } |
3316 | 6324 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
|
6325 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
|
6326 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6327 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
|
6328 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6329 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6330 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6331 unsigned int x, y; |
2967 | 6332 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6333 // 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
|
6334 // 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
|
6335 // 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
|
6336 ptr= h->cabac.bytestream; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6337 if (h->cabac.low&0x1) ptr-=CABAC_BITS/8; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6338 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6339 // 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
|
6340 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6341 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
|
6342 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6343 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6344 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
|
6345 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6346 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6347 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6348 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
|
6349 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6350 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
|
6351 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
|
6352 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6353 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6354 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6355 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
|
6356 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6357 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
|
6358 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
|
6359 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6360 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6361 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6362 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
|
6363 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6364 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6365 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
|
6366 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
|
6367 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6368 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
|
6369 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
|
6370 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6371 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6372 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
|
6373 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
|
6374 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6375 |
3316 | 6376 if(MB_MBAFF){ |
6377 h->ref_count[0] <<= 1; | |
6378 h->ref_count[1] <<= 1; | |
6379 } | |
6380 | |
2449 | 6381 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
|
6382 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6383 if( IS_INTRA( mb_type ) ) { |
2755 | 6384 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
|
6385 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6386 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6387 mb_type |= MB_TYPE_8x8DCT; | |
6388 for( i = 0; i < 16; i+=4 ) { | |
6389 int pred = pred_intra_mode( h, i ); | |
6390 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6391 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6392 } | |
6393 } else { | |
6394 for( i = 0; i < 16; i++ ) { | |
6395 int pred = pred_intra_mode( h, i ); | |
6396 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
|
6397 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6398 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6399 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6400 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6401 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
|
6402 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
|
6403 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6404 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
|
6405 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
|
6406 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6407 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
|
6408 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
|
6409 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6410 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
|
6411 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
|
6412 } 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
|
6413 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
|
6414 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6415 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
|
6416 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
|
6417 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
|
6418 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
|
6419 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
|
6420 } |
3482 | 6421 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6422 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6423 pred_direct_motion(h, &mb_type); |
6424 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6425 for( i = 0; i < 4; i++ ) | |
6426 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6427 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6428 } | |
6429 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6430 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6431 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
|
6432 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
|
6433 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
|
6434 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
|
6435 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6436 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6437 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6438 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
|
6439 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
|
6440 for( i = 0; i < 4; i++ ) { |
2396 | 6441 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6442 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
|
6443 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
|
6444 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
|
6445 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6446 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
|
6447 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6448 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
|
6449 } |
2110 | 6450 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
|
6451 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
|
6452 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6453 } |
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 |
2755 | 6456 if(dct8x8_allowed) |
6457 dct8x8_allowed = get_dct8x8_allowed(h); | |
6458 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6459 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
|
6460 for(i=0; i<4; i++){ |
2396 | 6461 if(IS_DIRECT(h->sub_mb_type[i])){ |
6462 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6463 continue; | |
6464 } | |
2110 | 6465 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
|
6466 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6467 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
|
6468 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
|
6469 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
|
6470 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
|
6471 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
|
6472 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
|
6473 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
|
6474 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
|
6475 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
|
6476 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
|
6477 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6478 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
|
6479 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
|
6480 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
|
6481 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6482 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
|
6483 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
|
6484 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
|
6485 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
|
6486 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
|
6487 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6488 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
|
6489 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
|
6490 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
|
6491 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
|
6492 }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
|
6493 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
|
6494 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
|
6495 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6496 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
|
6497 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
|
6498 }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
|
6499 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
|
6500 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
|
6501 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6502 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
|
6503 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
|
6504 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6505 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
|
6506 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
|
6507 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
|
6508 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6509 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
|
6510 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
|
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 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6514 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
|
6515 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
|
6516 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
|
6517 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
|
6518 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6519 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6520 } |
2396 | 6521 } else if( IS_DIRECT(mb_type) ) { |
6522 pred_direct_motion(h, &mb_type); | |
6523 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6524 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6525 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6526 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6527 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
|
6528 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
|
6529 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
|
6530 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
|
6531 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
|
6532 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
|
6533 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
|
6534 } |
2523 | 6535 }else |
6536 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
|
6537 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6538 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6539 if(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
|
6540 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
|
6541 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6542 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6543 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6544 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
|
6545 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6546 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 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
|
6547 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6548 }else |
6549 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
|
6550 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6551 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6552 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
|
6553 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
|
6554 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
|
6555 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
|
6556 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
|
6557 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
|
6558 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6559 }else |
6560 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
|
6561 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6562 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6563 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6564 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
|
6565 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
|
6566 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
|
6567 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
|
6568 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
|
6569 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
|
6570 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
|
6571 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6572 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
|
6573 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6574 }else{ |
2396 | 6575 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6576 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
|
6577 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6578 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6579 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6580 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6581 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
|
6582 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
|
6583 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
|
6584 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
|
6585 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
|
6586 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
|
6587 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6588 }else |
6589 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
|
6590 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6591 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6592 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6593 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
|
6594 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
|
6595 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
|
6596 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
|
6597 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
|
6598 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
|
6599 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6600 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
|
6601 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
|
6602 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6603 }else{ |
2396 | 6604 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6605 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
|
6606 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6607 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6608 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6609 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6610 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6611 |
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
|
6612 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
|
6613 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
|
6614 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
|
6615 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6616 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6617 if( !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
|
6618 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
|
6619 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
|
6620 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6621 |
3651 | 6622 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
|
6623 |
2755 | 6624 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6625 if( decode_cabac_mb_transform_size( h ) ) | |
6626 mb_type |= MB_TYPE_8x8DCT; | |
6627 } | |
6628 s->current_picture.mb_type[mb_xy]= mb_type; | |
6629 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6630 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6631 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
|
6632 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
|
6633 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6634 if(IS_INTERLACED(mb_type)){ |
3316 | 6635 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6636 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
|
6637 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
|
6638 }else{ |
3316 | 6639 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6640 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
|
6641 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
|
6642 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6643 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6644 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
|
6645 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6646 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
|
6647 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6648 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6649 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
|
6650 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
|
6651 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
|
6652 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
|
6653 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6654 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
|
6655 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6656 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
|
6657 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
|
6658 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6659 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
|
6660 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
|
6661 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
|
6662 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
|
6663 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6664 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
|
6665 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
|
6666 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6667 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6668 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
|
6669 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6670 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6671 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
|
6672 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
|
6673 if( cbp & (1<<i8x8) ) { |
2755 | 6674 if( IS_8x8DCT(mb_type) ) { |
6675 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6676 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6677 return -1; |
6678 } 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
|
6679 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
|
6680 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
|
6681 //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
|
6682 //START_TIMER |
2919 | 6683 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
|
6684 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6685 //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
|
6686 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6687 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6688 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
|
6689 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
|
6690 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6691 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6692 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6693 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6694 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
|
6695 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
|
6696 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
|
6697 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6698 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
|
6699 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
|
6700 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6701 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6702 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6703 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
|
6704 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
|
6705 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
|
6706 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
|
6707 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
|
6708 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6709 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
|
6710 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
|
6711 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6712 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6713 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6714 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
|
6715 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
|
6716 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
|
6717 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6718 } else { |
2315 | 6719 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6720 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6721 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6722 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6723 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
|
6724 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6725 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6726 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
|
6727 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
|
6728 |
3316 | 6729 if(MB_MBAFF){ |
6730 h->ref_count[0] >>= 1; | |
6731 h->ref_count[1] >>= 1; | |
6732 } | |
6733 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6734 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
|
6735 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6736 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6737 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6738 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
|
6739 int i, d; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6740 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6741 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6742 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6743 |
2633 | 6744 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
|
6745 int8_t tc[4]; |
2633 | 6746 for(i=0; i<4; i++) |
6747 tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1; | |
6748 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); | |
6749 } else { | |
6750 /* 16px edge length, because bS=4 is triggered by being at | |
6751 * the edge of an intra MB, so all 4 bS are the same */ | |
6752 for( d = 0; d < 16; d++ ) { | |
1898 | 6753 const int p0 = pix[-1]; |
6754 const int p1 = pix[-2]; | |
6755 const int p2 = pix[-3]; | |
6756 | |
6757 const int q0 = pix[0]; | |
6758 const int q1 = pix[1]; | |
6759 const int q2 = pix[2]; | |
6760 | |
4001 | 6761 if( FFABS( p0 - q0 ) < alpha && |
6762 FFABS( p1 - p0 ) < beta && | |
6763 FFABS( q1 - q0 ) < beta ) { | |
6764 | |
6765 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6766 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6767 { |
6768 const int p3 = pix[-4]; | |
6769 /* p0', p1', p2' */ | |
6770 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6771 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6772 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6773 } else { | |
6774 /* p0' */ | |
6775 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6776 } | |
4001 | 6777 if( FFABS( q2 - q0 ) < beta) |
1898 | 6778 { |
6779 const int q3 = pix[3]; | |
6780 /* q0', q1', q2' */ | |
6781 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6782 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6783 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6784 } else { | |
6785 /* q0' */ | |
6786 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6787 } | |
6788 }else{ | |
6789 /* p0', q0' */ | |
6790 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6791 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6792 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6793 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
|
6794 } |
1898 | 6795 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
|
6796 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6797 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6798 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6799 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6800 int i; |
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
|
6801 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6802 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6803 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6804 |
2633 | 6805 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
|
6806 int8_t tc[4]; |
2633 | 6807 for(i=0; i<4; i++) |
6808 tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0; | |
6809 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); | |
6810 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6811 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
|
6812 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6813 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6814 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6815 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
|
6816 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6817 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
|
6818 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6819 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6820 int beta; |
2967 | 6821 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6822 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6823 int bS_index = (i >> 1); |
3316 | 6824 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6825 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6826 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6827 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6829 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6830 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6831 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6832 |
3316 | 6833 qp_index = MB_FIELD ? (i >> 3) : (i & 1); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6834 index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6835 alpha = alpha_table[index_a]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6836 beta = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6837 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6838 if( bS[bS_index] < 4 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6839 const int tc0 = tc0_table[index_a][bS[bS_index] - 1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6840 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6841 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6842 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6843 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6844 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6845 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 |
4001 | 6847 if( FFABS( p0 - q0 ) < alpha && |
6848 FFABS( p1 - p0 ) < beta && | |
6849 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6850 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6851 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6852 |
4001 | 6853 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6854 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
|
6855 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6856 } |
4001 | 6857 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6858 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
|
6859 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6860 } |
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 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
|
6863 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
|
6864 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
|
6865 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
|
6866 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6867 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6868 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6869 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6870 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6871 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6872 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6873 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6874 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6875 |
4001 | 6876 if( FFABS( p0 - q0 ) < alpha && |
6877 FFABS( p1 - p0 ) < beta && | |
6878 FFABS( q1 - q0 ) < beta ) { | |
6879 | |
6880 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6881 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6882 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6883 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6884 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6885 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
|
6886 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
|
6887 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
|
6888 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6889 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6890 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
|
6891 } |
4001 | 6892 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6893 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6894 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6895 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6896 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
|
6897 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
|
6898 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
|
6899 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6900 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6901 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
|
6902 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6903 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6904 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6905 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
|
6906 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
|
6907 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6908 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
|
6909 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6910 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6911 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6912 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6913 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
|
6914 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6915 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
|
6916 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6917 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6918 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6919 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6920 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6921 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6922 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6923 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6924 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6925 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6926 |
3316 | 6927 qp_index = MB_FIELD ? (i >> 2) : (i & 1); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6928 index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6929 alpha = alpha_table[index_a]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6930 beta = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )]; |
3316 | 6931 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6932 if( bS[bS_index] < 4 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6933 const int tc = tc0_table[index_a][bS[bS_index] - 1] + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6934 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6935 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6936 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6937 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6938 |
4001 | 6939 if( FFABS( p0 - q0 ) < alpha && |
6940 FFABS( p1 - p0 ) < beta && | |
6941 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6942 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
|
6943 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6944 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
|
6945 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
|
6946 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
|
6947 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6948 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6949 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6950 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6951 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6952 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6953 |
4001 | 6954 if( FFABS( p0 - q0 ) < alpha && |
6955 FFABS( p1 - p0 ) < beta && | |
6956 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6957 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6958 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
|
6959 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
|
6960 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
|
6961 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6962 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6963 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6964 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6965 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6966 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
|
6967 int i, d; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6968 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6969 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6970 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6971 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
|
6972 |
2633 | 6973 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
|
6974 int8_t tc[4]; |
2633 | 6975 for(i=0; i<4; i++) |
6976 tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1; | |
6977 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); | |
6978 } else { | |
6979 /* 16px edge length, see filter_mb_edgev */ | |
6980 for( d = 0; d < 16; d++ ) { | |
1898 | 6981 const int p0 = pix[-1*pix_next]; |
6982 const int p1 = pix[-2*pix_next]; | |
6983 const int p2 = pix[-3*pix_next]; | |
6984 const int q0 = pix[0]; | |
6985 const int q1 = pix[1*pix_next]; | |
6986 const int q2 = pix[2*pix_next]; | |
6987 | |
4001 | 6988 if( FFABS( p0 - q0 ) < alpha && |
6989 FFABS( p1 - p0 ) < beta && | |
6990 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6991 |
6992 const int p3 = pix[-4*pix_next]; | |
6993 const int q3 = pix[ 3*pix_next]; | |
6994 | |
4001 | 6995 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6996 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6997 /* p0', p1', p2' */ |
6998 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6999 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
7000 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
7001 } else { | |
7002 /* p0' */ | |
7003 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
7004 } | |
4001 | 7005 if( FFABS( q2 - q0 ) < beta) { |
1898 | 7006 /* q0', q1', q2' */ |
7007 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
7008 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
7009 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
7010 } else { | |
7011 /* q0' */ | |
7012 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
7013 } | |
7014 }else{ | |
7015 /* p0', q0' */ | |
7016 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
7017 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
7018 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7019 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
|
7020 } |
1898 | 7021 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
|
7022 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7023 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7024 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7025 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 7027 int i; |
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
|
7028 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7029 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7030 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7031 |
2633 | 7032 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
|
7033 int8_t tc[4]; |
2633 | 7034 for(i=0; i<4; i++) |
7035 tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0; | |
7036 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); | |
7037 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
7038 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
|
7039 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7040 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7041 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 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
|
7043 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7045 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7046 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7047 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
|
7048 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
|
7049 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7050 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7051 assert(!FRAME_MBAFF); |
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 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7054 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7055 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7056 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7057 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7058 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7059 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7060 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7061 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7062 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7063 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7064 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 7065 qp_thresh = 15 - h->slice_alpha_c0_offset; |
7066 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
7067 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
7068 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7069 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7070 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7071 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7072 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7073 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7074 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7075 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7076 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7077 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7078 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7079 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7080 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7081 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7082 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7083 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7084 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7085 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7086 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7087 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7088 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7089 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7090 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7091 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7092 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7093 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7094 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7095 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7096 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7097 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7098 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7099 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7100 int edges; |
7101 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7102 edges = 4; | |
7103 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7104 } else { | |
7105 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7106 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7107 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7108 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7109 ? 3 : 0; | |
7110 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7111 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7112 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7113 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7114 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7115 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7116 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7117 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7118 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7119 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7120 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7121 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7122 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
|
7123 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7124 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
|
7125 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
|
7126 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7127 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7128 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7129 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7130 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7131 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7132 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7133 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7134 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7135 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7136 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7137 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7138 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7139 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7140 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7141 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7142 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7143 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7144 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7145 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7146 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7147 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7148 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7149 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7150 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
|
7151 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
|
7152 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7153 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7154 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
|
7155 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
|
7156 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7157 /* 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
|
7158 * 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
|
7159 * frame numbers, not indices. */ |
3316 | 7160 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7161 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
|
7162 |
3101 | 7163 //for sufficiently low qp, filtering wouldn't do anything |
7164 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7165 if(!FRAME_MBAFF){ |
3101 | 7166 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7167 int qp = s->current_picture.qscale_table[mb_xy]; | |
7168 if(qp <= qp_thresh | |
7169 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7170 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7171 return; | |
7172 } | |
7173 } | |
7174 | |
3316 | 7175 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7176 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7177 && 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
|
7178 // and current and left pair do not have the same interlaced type |
3316 | 7179 && (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
|
7180 // 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
|
7181 && (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
|
7182 /* 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
|
7183 * 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
|
7184 */ |
3316 | 7185 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7186 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
|
7187 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7188 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7189 int chroma_qp[2]; |
3316 | 7190 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
|
7191 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7192 first_vertical_edge_done = 1; |
3316 | 7193 |
7194 if( IS_INTRA(mb_type) ) | |
7195 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7196 else { | |
7197 for( i = 0; i < 8; i++ ) { | |
7198 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7199 | |
7200 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7201 bS[i] = 4; | |
7202 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7203 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7204 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7205 bS[i] = 2; | |
7206 else | |
7207 bS[i] = 1; | |
7208 } | |
7209 } | |
7210 | |
7211 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7212 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7213 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7214 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7215 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7216 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7217 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7218 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7219 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7220 | |
7221 /* Filter edge */ | |
7222 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); | |
7223 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7224 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7225 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7226 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
|
7227 } |
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
|
7228 /* 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
|
7229 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
|
7230 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7231 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7232 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7233 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7234 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7235 | |
3101 | 7236 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7237 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7238 // how often to recheck mv-based bS when iterating between edges |
7239 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7240 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7241 // how often to recheck mv-based bS when iterating along each edge | |
7242 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7243 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7244 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7245 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7246 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7247 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7248 |
2454 | 7249 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
|
7250 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
|
7251 |
3316 | 7252 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7253 && !IS_INTERLACED(mb_type) | |
7254 && IS_INTERLACED(mbm_type) | |
7255 ) { | |
7256 // This is a special case in the norm where the filtering must | |
7257 // be done twice (one each of the field) even if we are in a | |
7258 // frame macroblock. | |
7259 // | |
7260 static const int nnz_idx[4] = {4,5,6,3}; | |
7261 unsigned int tmp_linesize = 2 * linesize; | |
7262 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7263 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7264 int qp, chroma_qp; | |
7265 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7266 int16_t bS[4]; |
3316 | 7267 |
7268 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7269 if( IS_INTRA(mb_type) || | |
7270 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7271 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7272 } else { | |
7273 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7274 for( i = 0; i < 4; i++ ) { | |
7275 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7276 mbn_nnz[nnz_idx[i]] != 0 ) | |
7277 bS[i] = 2; | |
7278 else | |
7279 bS[i] = 1; | |
7280 } | |
7281 } | |
7282 // Do not use s->qscale as luma quantizer because it has not the same | |
7283 // value in IPCM macroblocks. | |
7284 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7285 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); | |
7286 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7287 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7288 chroma_qp = ( h->chroma_qp + | |
7289 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7290 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7291 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7292 } | |
7293 | |
7294 start = 1; | |
7295 } | |
7296 | |
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
|
7297 /* Calculate bS */ |
2924 | 7298 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7299 /* mbn_xy: neighbor macroblock */ |
2924 | 7300 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7301 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7302 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
|
7303 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
|
7304 |
2924 | 7305 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7306 continue; |
7307 | |
2924 | 7308 if( IS_INTRA(mb_type) || |
7309 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7310 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7311 if (edge == 0) { |
2924 | 7312 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7313 || ((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
|
7314 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7315 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7316 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7317 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7318 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7319 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7320 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7321 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7322 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
|
7323 } else { |
2924 | 7324 int i, l; |
7325 int mv_done; | |
7326 | |
7327 if( edge & mask_edge ) { | |
7328 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7329 mv_done = 1; | |
7330 } | |
3316 | 7331 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7332 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7333 mv_done = 1; | |
7334 } | |
2924 | 7335 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7336 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7337 int bn_idx= b_idx - (dir ? 8:1); | |
7338 int v = 0; | |
7339 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7340 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7341 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7342 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7343 } |
7344 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7345 mv_done = 1; | |
7346 } | |
7347 else | |
7348 mv_done = 0; | |
7349 | |
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
|
7350 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
|
7351 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
|
7352 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
|
7353 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
|
7354 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
|
7355 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7356 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7357 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
|
7358 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
|
7359 } |
2924 | 7360 else if(!mv_done) |
2523 | 7361 { |
7362 bS[i] = 0; | |
7363 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
|
7364 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7365 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7366 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7367 bS[i] = 1; |
7368 break; | |
7369 } | |
7370 } | |
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
|
7371 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7372 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7373 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7374 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
|
7375 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
|
7376 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7377 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7378 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7379 // 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
|
7380 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7381 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
|
7382 //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
|
7383 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
|
7384 { 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
|
7385 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
|
7386 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7387 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
|
7388 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
|
7389 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
|
7390 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
|
7391 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
|
7392 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7393 } 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
|
7394 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7395 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
|
7396 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
|
7397 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
|
7398 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
|
7399 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
|
7400 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7401 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7402 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7403 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7404 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7405 |
1168 | 7406 static int decode_slice(H264Context *h){ |
7407 MpegEncContext * const s = &h->s; | |
7408 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7409 | |
7410 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
|
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( 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
|
7413 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
|
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 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7416 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
|
7417 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7418 /* 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
|
7419 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
|
7420 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
|
7421 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7422 ( 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
|
7423 /* calculate pre-state */ |
2755 | 7424 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
|
7425 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
|
7426 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
|
7427 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
|
7428 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7429 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
|
7430 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7431 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7432 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
|
7433 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7434 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 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 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7438 //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
|
7439 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
|
7440 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
|
7441 //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
|
7442 |
2163 | 7443 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7444 |
3316 | 7445 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
|
7446 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
|
7447 |
2163 | 7448 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
|
7449 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7450 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7451 s->mb_y--; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7452 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7453 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
|
7454 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7455 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
|
7456 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
|
7457 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
|
7458 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7459 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7460 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7461 if( ++s->mb_x >= s->mb_width ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7462 s->mb_x = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7463 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7464 ++s->mb_y; |
3316 | 7465 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7466 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7467 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7468 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7469 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7470 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7471 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
|
7472 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7473 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
|
7474 } |
1168 | 7475 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7476 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7477 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7478 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7479 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
|
7480 |
2163 | 7481 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
|
7482 |
3316 | 7483 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
|
7484 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
|
7485 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
|
7486 |
2163 | 7487 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
|
7488 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
|
7489 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7490 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7491 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
|
7492 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
|
7493 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
|
7494 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7495 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
|
7496 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7497 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7498 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
|
7499 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
|
7500 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
|
7501 ++s->mb_y; |
3316 | 7502 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7503 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7504 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7505 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
|
7506 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
|
7507 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7508 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
|
7509 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7510 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7511 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
|
7512 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7513 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7514 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7515 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
|
7516 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7517 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7518 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7519 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7520 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7521 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
|
7522 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7523 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); |
7524 | |
7525 return 0; | |
7526 }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
|
7527 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 | 7528 |
7529 return -1; | |
7530 } | |
7531 } | |
7532 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7533 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7534 |
1168 | 7535 #if 0 |
7536 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7537 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7538 int ret= decode_mb(h); | |
2967 | 7539 |
1168 | 7540 hl_decode_mb(h); |
7541 | |
7542 if(ret<0){ | |
3177 | 7543 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7544 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); |
7545 | |
7546 return -1; | |
7547 } | |
2967 | 7548 |
1168 | 7549 if(++s->mb_x >= s->mb_width){ |
7550 s->mb_x=0; | |
7551 if(++s->mb_y >= s->mb_height){ | |
7552 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7553 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); | |
7554 | |
7555 return 0; | |
7556 }else{ | |
7557 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); | |
7558 | |
7559 return -1; | |
7560 } | |
7561 } | |
7562 } | |
2967 | 7563 |
1168 | 7564 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7565 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7566 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); | |
7567 | |
7568 return 0; | |
7569 }else{ | |
7570 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); | |
7571 | |
7572 return -1; | |
7573 } | |
7574 } | |
7575 } | |
7576 s->mb_x=0; | |
7577 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7578 } | |
7579 #endif | |
7580 return -1; //not reached | |
7581 } | |
7582 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7583 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
|
7584 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7585 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7586 int e, build, i; |
2967 | 7587 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7588 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7589 return -1; |
2967 | 7590 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7591 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
|
7592 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
|
7593 } |
2967 | 7594 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7595 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7596 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
|
7597 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7598 h->x264_build= build; |
2967 | 7599 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7600 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
|
7601 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
|
7602 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7603 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7604 skip_bits(&s->gb, 8); |
2967 | 7605 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7606 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7607 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7608 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7609 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7610 MpegEncContext * const s = &h->s; |
2967 | 7611 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7612 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
|
7613 int size, type; |
2967 | 7614 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7615 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7616 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7617 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7618 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7619 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7620 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7621 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7622 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7623 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7624 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7625 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7626 case 5: |
3318 | 7627 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
|
7628 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7629 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7630 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7631 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7632 } |
2967 | 7633 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7634 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7635 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7636 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7637 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7638 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7639 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7640 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7641 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
|
7642 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7643 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7644 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
|
7645 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
|
7646 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
|
7647 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
|
7648 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
|
7649 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
|
7650 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
|
7651 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7652 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
|
7653 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
|
7654 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
|
7655 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
|
7656 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7657 |
1168 | 7658 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7659 MpegEncContext * const s = &h->s; | |
7660 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
|
7661 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7662 |
7663 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7664 |
1168 | 7665 if( aspect_ratio_info_present_flag ) { |
7666 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7667 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7668 sps->sar.num= get_bits(&s->gb, 16); |
7669 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
|
7670 }else if(aspect_ratio_idc < 14){ |
1548 | 7671 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7672 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7673 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7674 return -1; |
7675 } | |
7676 }else{ | |
2967 | 7677 sps->sar.num= |
1548 | 7678 sps->sar.den= 0; |
1168 | 7679 } |
7680 // 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
|
7681 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7682 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
|
7683 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
|
7684 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7685 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7686 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
|
7687 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
|
7688 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
|
7689 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
|
7690 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
|
7691 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
|
7692 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
|
7693 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7694 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7695 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7696 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
|
7697 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
|
7698 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
|
7699 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7700 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7701 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
|
7702 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
|
7703 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
|
7704 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
|
7705 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
|
7706 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7707 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7708 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
|
7709 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
|
7710 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7711 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
|
7712 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
|
7713 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7714 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
|
7715 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
|
7716 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
|
7717 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7718 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
|
7719 if(sps->bitstream_restriction_flag){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7720 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
|
7721 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
|
7722 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
|
7723 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
|
7724 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
|
7725 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
|
7726 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
|
7727 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7728 |
1168 | 7729 return 0; |
7730 } | |
7731 | |
3004 | 7732 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7733 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7734 MpegEncContext * const s = &h->s; |
7735 int i, last = 8, next = 8; | |
7736 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7737 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7738 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7739 else |
7740 for(i=0;i<size;i++){ | |
7741 if(next) | |
7742 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7743 if(!i && !next){ /* matrix not written, we use the preset one */ |
7744 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7745 break; |
7746 } | |
7747 last = factors[scan[i]] = next ? next : last; | |
7748 } | |
7749 } | |
7750 | |
7751 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7752 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7753 MpegEncContext * const s = &h->s; | |
7754 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7755 const uint8_t *fallback[4] = { | |
7756 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7757 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7758 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7759 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7760 }; | |
7761 if(get_bits1(&s->gb)){ | |
7762 sps->scaling_matrix_present |= is_sps; | |
3004 | 7763 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7764 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7765 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7766 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7767 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7768 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7769 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7770 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7771 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7772 } |
7773 } else if(fallback_sps) { | |
7774 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7775 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7776 } | |
7777 } | |
7778 | |
1168 | 7779 static inline int decode_seq_parameter_set(H264Context *h){ |
7780 MpegEncContext * const s = &h->s; | |
1371 | 7781 int profile_idc, level_idc; |
1168 | 7782 int sps_id, i; |
7783 SPS *sps; | |
2967 | 7784 |
1168 | 7785 profile_idc= get_bits(&s->gb, 8); |
1371 | 7786 get_bits1(&s->gb); //constraint_set0_flag |
7787 get_bits1(&s->gb); //constraint_set1_flag | |
7788 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7789 get_bits1(&s->gb); //constraint_set3_flag |
7790 get_bits(&s->gb, 4); // reserved | |
1168 | 7791 level_idc= get_bits(&s->gb, 8); |
7792 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7793 |
1168 | 7794 sps= &h->sps_buffer[ sps_id ]; |
7795 sps->profile_idc= profile_idc; | |
7796 sps->level_idc= level_idc; | |
2312 | 7797 |
2755 | 7798 if(sps->profile_idc >= 100){ //high profile |
7799 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7800 get_bits1(&s->gb); //residual_color_transform_flag | |
7801 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7802 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7803 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7804 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7805 }else | |
7806 sps->scaling_matrix_present = 0; | |
2755 | 7807 |
1168 | 7808 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7809 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7810 |
1168 | 7811 if(sps->poc_type == 0){ //FIXME #define |
7812 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7813 } else if(sps->poc_type == 1){//FIXME #define | |
7814 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7815 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7816 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
7817 sps->poc_cycle_length= get_ue_golomb(&s->gb); | |
2967 | 7818 |
1168 | 7819 for(i=0; i<sps->poc_cycle_length; i++) |
7820 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
7821 } | |
7822 if(sps->poc_type > 2){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7823 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7824 return -1; |
7825 } | |
7826 | |
7827 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
|
7828 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
|
7829 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
|
7830 } |
1371 | 7831 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
1168 | 7832 sps->mb_width= get_ue_golomb(&s->gb) + 1; |
7833 sps->mb_height= get_ue_golomb(&s->gb) + 1; | |
2967 | 7834 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 || |
2422 | 7835 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)) |
7836 return -1; | |
7837 | |
1168 | 7838 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7839 if(!sps->frame_mbs_only_flag) | |
7840 sps->mb_aff= get_bits1(&s->gb); | |
7841 else | |
7842 sps->mb_aff= 0; | |
7843 | |
7844 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7845 | |
3316 | 7846 #ifndef ALLOW_INTERLACE |
7847 if(sps->mb_aff) | |
3954 | 7848 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7849 #endif |
7850 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7851 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7852 | |
1371 | 7853 sps->crop= get_bits1(&s->gb); |
7854 if(sps->crop){ | |
7855 sps->crop_left = get_ue_golomb(&s->gb); | |
7856 sps->crop_right = get_ue_golomb(&s->gb); | |
7857 sps->crop_top = get_ue_golomb(&s->gb); | |
7858 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7859 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
|
7860 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7861 } |
7862 }else{ | |
2967 | 7863 sps->crop_left = |
7864 sps->crop_right = | |
7865 sps->crop_top = | |
1371 | 7866 sps->crop_bottom= 0; |
7867 } | |
7868 | |
1168 | 7869 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7870 if( sps->vui_parameters_present_flag ) | |
7871 decode_vui_parameters(h, sps); | |
2967 | 7872 |
1168 | 7873 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 7874 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n", |
1168 | 7875 sps_id, sps->profile_idc, sps->level_idc, |
7876 sps->poc_type, | |
7877 sps->ref_frame_count, | |
7878 sps->mb_width, sps->mb_height, | |
7879 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7880 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7881 sps->crop_left, sps->crop_right, |
7882 sps->crop_top, sps->crop_bottom, | |
1168 | 7883 sps->vui_parameters_present_flag ? "VUI" : "" |
7884 ); | |
7885 } | |
7886 return 0; | |
7887 } | |
7888 | |
2755 | 7889 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7890 MpegEncContext * const s = &h->s; |
7891 int pps_id= get_ue_golomb(&s->gb); | |
7892 PPS *pps= &h->pps_buffer[pps_id]; | |
2967 | 7893 |
1168 | 7894 pps->sps_id= get_ue_golomb(&s->gb); |
7895 pps->cabac= get_bits1(&s->gb); | |
7896 pps->pic_order_present= get_bits1(&s->gb); | |
7897 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7898 if(pps->slice_group_count > 1 ){ | |
7899 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
|
7900 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7901 switch(pps->mb_slice_group_map_type){ |
7902 case 0: | |
7903 #if 0 | |
7904 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7905 | run_length[ i ] |1 |ue(v) | | |
7906 #endif | |
7907 break; | |
7908 case 2: | |
7909 #if 0 | |
7910 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7911 |{ | | | | |
7912 | top_left_mb[ i ] |1 |ue(v) | | |
7913 | bottom_right_mb[ i ] |1 |ue(v) | | |
7914 | } | | | | |
7915 #endif | |
7916 break; | |
7917 case 3: | |
7918 case 4: | |
7919 case 5: | |
7920 #if 0 | |
7921 | slice_group_change_direction_flag |1 |u(1) | | |
7922 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7923 #endif | |
7924 break; | |
7925 case 6: | |
7926 #if 0 | |
7927 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7928 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7929 |) | | | | |
7930 | slice_group_id[ i ] |1 |u(v) | | |
7931 #endif | |
1214 | 7932 break; |
1168 | 7933 } |
7934 } | |
7935 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7936 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
7937 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
|
7938 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
1168 | 7939 return -1; |
7940 } | |
2967 | 7941 |
1168 | 7942 pps->weighted_pred= get_bits1(&s->gb); |
7943 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7944 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7945 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7946 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7947 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7948 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7949 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7950 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7951 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
|
7952 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7953 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7954 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7955 |
7956 if(get_bits_count(&s->gb) < bit_length){ | |
7957 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7958 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7959 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7960 } | |
2967 | 7961 |
1168 | 7962 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 7963 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n", |
1168 | 7964 pps_id, pps->sps_id, |
7965 pps->cabac ? "CABAC" : "CAVLC", | |
7966 pps->slice_group_count, | |
7967 pps->ref_count[0], pps->ref_count[1], | |
7968 pps->weighted_pred ? "weighted" : "", | |
7969 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7970 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7971 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7972 pps->redundant_pic_cnt_present ? "REDU" : "", |
7973 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7974 ); |
7975 } | |
2967 | 7976 |
1168 | 7977 return 0; |
7978 } | |
7979 | |
7980 /** | |
7981 * finds the end of the current frame in the bitstream. | |
7982 * @return the position of the first byte of the next frame, or -1 | |
7983 */ | |
2392 | 7984 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7985 int i; |
1168 | 7986 uint32_t state; |
2392 | 7987 ParseContext *pc = &(h->s.parse_context); |
1168 | 7988 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7989 // mb_addr= pc->mb_addr - 1; | |
7990 state= pc->state; | |
2392 | 7991 for(i=0; i<=buf_size; i++){ |
1168 | 7992 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7993 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7994 if(pc->frame_start_found){ |
2392 | 7995 // If there isn't one more byte in the buffer |
7996 // the test on first_mb_in_slice cannot be done yet | |
7997 // do it at next call. | |
7998 if (i >= buf_size) break; | |
7999 if (buf[i] & 0x80) { | |
8000 // first_mb_in_slice is 0, probably the first nal of a new | |
8001 // slice | |
8002 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 8003 pc->state=-1; |
2392 | 8004 pc->frame_start_found= 0; |
8005 return i-4; | |
8006 } | |
1168 | 8007 } |
2392 | 8008 pc->frame_start_found = 1; |
1168 | 8009 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8010 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
|
8011 if(pc->frame_start_found){ |
2967 | 8012 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8013 pc->frame_start_found= 0; |
2967 | 8014 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8015 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8016 } |
2392 | 8017 if (i<buf_size) |
8018 state= (state<<8) | buf[i]; | |
1168 | 8019 } |
2967 | 8020 |
1168 | 8021 pc->state= state; |
1219 | 8022 return END_NOT_FOUND; |
1168 | 8023 } |
8024 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8025 #ifdef CONFIG_H264_PARSER |
1988 | 8026 static int h264_parse(AVCodecParserContext *s, |
8027 AVCodecContext *avctx, | |
2967 | 8028 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 8029 const uint8_t *buf, int buf_size) |
8030 { | |
2392 | 8031 H264Context *h = s->priv_data; |
8032 ParseContext *pc = &h->s.parse_context; | |
1988 | 8033 int next; |
2967 | 8034 |
2392 | 8035 next= find_frame_end(h, buf, buf_size); |
1988 | 8036 |
8037 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
8038 *poutbuf = NULL; | |
8039 *poutbuf_size = 0; | |
8040 return buf_size; | |
8041 } | |
8042 | |
8043 *poutbuf = (uint8_t *)buf; | |
8044 *poutbuf_size = buf_size; | |
8045 return next; | |
8046 } | |
8047 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8048 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8049 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8050 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8051 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8052 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8053 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8054 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8055 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8056 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8057 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8058 /* 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
|
8059 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8060 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
|
8061 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8062 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
|
8063 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8064 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8065 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8066 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8067 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8068 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8069 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8070 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8071 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8072 |
1168 | 8073 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
8074 MpegEncContext * const s = &h->s; | |
8075 AVCodecContext * const avctx= s->avctx; | |
8076 int buf_index=0; | |
1322 | 8077 #if 0 |
1168 | 8078 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8079 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8080 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 8081 } |
8082 #endif | |
2392 | 8083 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8084 s->current_picture_ptr= NULL; |
1168 | 8085 for(;;){ |
8086 int consumed; | |
8087 int dst_length; | |
8088 int bit_length; | |
8089 uint8_t *ptr; | |
2227 | 8090 int i, nalsize = 0; |
2967 | 8091 |
2227 | 8092 if(h->is_avc) { |
8093 if(buf_index >= buf_size) break; | |
8094 nalsize = 0; | |
8095 for(i = 0; i < h->nal_length_size; i++) | |
8096 nalsize = (nalsize << 8) | buf[buf_index++]; | |
3126 | 8097 if(nalsize <= 1){ |
8098 if(nalsize == 1){ | |
8099 buf_index++; | |
8100 continue; | |
8101 }else{ | |
8102 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8103 break; | |
8104 } | |
8105 } | |
2227 | 8106 } else { |
1168 | 8107 // start code prefix search |
8108 for(; buf_index + 3 < buf_size; buf_index++){ | |
8109 // this should allways succeed in the first iteration | |
8110 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8111 break; | |
8112 } | |
2967 | 8113 |
1168 | 8114 if(buf_index+3 >= buf_size) break; |
2967 | 8115 |
1168 | 8116 buf_index+=3; |
2967 | 8117 } |
8118 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8119 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
3341 | 8120 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8121 dst_length--; | |
1168 | 8122 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8123 | |
8124 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8125 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 | 8126 } |
2967 | 8127 |
2227 | 8128 if (h->is_avc && (nalsize != consumed)) |
8129 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8130 | |
1168 | 8131 buf_index += consumed; |
8132 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8133 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8134 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8135 continue; |
2967 | 8136 |
1168 | 8137 switch(h->nal_unit_type){ |
8138 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8139 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8140 case NAL_SLICE: |
8141 init_get_bits(&s->gb, ptr, bit_length); | |
8142 h->intra_gb_ptr= | |
8143 h->inter_gb_ptr= &s->gb; | |
8144 s->data_partitioning = 0; | |
2967 | 8145 |
2771 | 8146 if(decode_slice_header(h) < 0){ |
8147 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8148 break; | |
8149 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8150 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8151 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8152 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8153 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8154 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8155 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8156 decode_slice(h); |
8157 break; | |
8158 case NAL_DPA: | |
8159 init_get_bits(&s->gb, ptr, bit_length); | |
8160 h->intra_gb_ptr= | |
8161 h->inter_gb_ptr= NULL; | |
8162 s->data_partitioning = 1; | |
2967 | 8163 |
2771 | 8164 if(decode_slice_header(h) < 0){ |
8165 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8166 } | |
1168 | 8167 break; |
8168 case NAL_DPB: | |
8169 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8170 h->intra_gb_ptr= &h->intra_gb; | |
8171 break; | |
8172 case NAL_DPC: | |
8173 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8174 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8175 |
2967 | 8176 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning |
2793 | 8177 && s->hurry_up < 5 |
8178 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8179 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8180 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8181 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8182 decode_slice(h); |
8183 break; | |
8184 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8185 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
|
8186 decode_sei(h); |
1168 | 8187 break; |
8188 case NAL_SPS: | |
8189 init_get_bits(&s->gb, ptr, bit_length); | |
8190 decode_seq_parameter_set(h); | |
2967 | 8191 |
1168 | 8192 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8193 s->low_delay=1; | |
2967 | 8194 |
2538 | 8195 if(avctx->has_b_frames < 2) |
8196 avctx->has_b_frames= !s->low_delay; | |
1168 | 8197 break; |
8198 case NAL_PPS: | |
8199 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8200 |
2755 | 8201 decode_picture_parameter_set(h, bit_length); |
1168 | 8202 |
8203 break; | |
2960 | 8204 case NAL_AUD: |
8205 case NAL_END_SEQUENCE: | |
8206 case NAL_END_STREAM: | |
8207 case NAL_FILLER_DATA: | |
8208 case NAL_SPS_EXT: | |
8209 case NAL_AUXILIARY_SLICE: | |
1168 | 8210 break; |
2979 | 8211 default: |
8212 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8213 } |
8214 } | |
8215 | |
1174 | 8216 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
|
8217 |
2971 | 8218 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
|
8219 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8220 |
1168 | 8221 h->prev_frame_num_offset= h->frame_num_offset; |
8222 h->prev_frame_num= h->frame_num; | |
8223 if(s->current_picture_ptr->reference){ | |
8224 h->prev_poc_msb= h->poc_msb; | |
8225 h->prev_poc_lsb= h->poc_lsb; | |
8226 } | |
8227 if(s->current_picture_ptr->reference) | |
8228 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8229 | |
8230 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
|
8231 |
1168 | 8232 MPV_frame_end(s); |
8233 | |
8234 return buf_index; | |
8235 } | |
8236 | |
8237 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8238 * returns the number of bytes consumed for building the current frame |
1168 | 8239 */ |
8240 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8241 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8242 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8243 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8244 |
1168 | 8245 return pos; |
8246 }else{ | |
8247 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8248 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8249 | |
8250 return pos; | |
8251 } | |
8252 } | |
8253 | |
2967 | 8254 static int decode_frame(AVCodecContext *avctx, |
1168 | 8255 void *data, int *data_size, |
8256 uint8_t *buf, int buf_size) | |
8257 { | |
8258 H264Context *h = avctx->priv_data; | |
8259 MpegEncContext *s = &h->s; | |
2967 | 8260 AVFrame *pict = data; |
1168 | 8261 int buf_index; |
2967 | 8262 |
1168 | 8263 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8264 s->flags2= avctx->flags2; |
1168 | 8265 |
8266 /* no supplementary picture */ | |
8267 if (buf_size == 0) { | |
8268 return 0; | |
8269 } | |
2967 | 8270 |
1168 | 8271 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8272 int next= find_frame_end(h, buf, buf_size); |
2967 | 8273 |
1988 | 8274 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8275 return buf_size; |
8276 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8277 } | |
8278 | |
2227 | 8279 if(h->is_avc && !h->got_avcC) { |
8280 int i, cnt, nalsize; | |
8281 unsigned char *p = avctx->extradata; | |
8282 if(avctx->extradata_size < 7) { | |
8283 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8284 return -1; | |
8285 } | |
8286 if(*p != 1) { | |
8287 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8288 return -1; | |
8289 } | |
8290 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8291 so put a fake nal_length_size = 2 while parsing them */ | |
8292 h->nal_length_size = 2; | |
8293 // Decode sps from avcC | |
8294 cnt = *(p+5) & 0x1f; // Number of sps | |
8295 p += 6; | |
8296 for (i = 0; i < cnt; i++) { | |
8297 nalsize = BE_16(p) + 2; | |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8298 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8299 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8300 return -1; | |
8301 } | |
8302 p += nalsize; | |
2967 | 8303 } |
2227 | 8304 // Decode pps from avcC |
8305 cnt = *(p++); // Number of pps | |
8306 for (i = 0; i < cnt; i++) { | |
8307 nalsize = BE_16(p) + 2; | |
8308 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
8309 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8310 return -1; | |
8311 } | |
8312 p += nalsize; | |
2967 | 8313 } |
2227 | 8314 // Now store right nal length size, that will be use to parse all other nals |
8315 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8316 // Do not reparse avcC | |
8317 h->got_avcC = 1; | |
8318 } | |
8319 | |
8320 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){ | |
2967 | 8321 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8322 return -1; |
8323 } | |
8324 | |
8325 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8326 if(buf_index < 0) |
1168 | 8327 return -1; |
8328 | |
2967 | 8329 //FIXME do something with unavailable reference frames |
8330 | |
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
|
8331 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8332 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8333 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8334 return -1; |
8335 } | |
8336 | |
2409 | 8337 { |
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
|
8338 Picture *out = s->current_picture_ptr; |
2561 | 8339 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8340 *data_size = sizeof(AVFrame); |
2561 | 8341 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8342 /* Sort B-frames into display order */ |
2409 | 8343 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
|
8344 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8345 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
|
8346 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8347 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
|
8348 && s->avctx->has_b_frames < h->sps.num_reorder_frames){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8349 s->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
|
8350 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8351 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8352 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8353 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8354 while(h->delayed_pic[pics]) pics++; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8355 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
|
8356 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8357 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8358 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8359 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8360 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
|
8361 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
|
8362 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8363 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8364 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8365 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8366 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
|
8367 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
|
8368 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8369 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8370 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8371 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8372 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8373 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8374 { } | |
8375 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
|
8376 out = prev; |
2923 | 8377 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8378 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8379 ((!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
|
8380 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8381 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8382 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8383 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8384 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8385 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8386 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8387 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8388 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8389 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
|
8390 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
|
8391 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
|
8392 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8393 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8394 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8395 *data_size = 0; |
2561 | 8396 else |
8397 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8398 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
|
8399 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8400 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
|
8401 #endif |
2409 | 8402 |
2937 | 8403 if(out) |
8404 *pict= *(AVFrame*)out; | |
8405 else | |
8406 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8407 } | |
8408 | |
8409 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
|
8410 ff_print_debug_info(s, pict); |
1168 | 8411 //printf("out %d\n", (int)pict->data[0]); |
8412 #if 0 //? | |
8413 | |
8414 /* Return the Picture timestamp as the frame number */ | |
8415 /* we substract 1 because it is added on utils.c */ | |
8416 avctx->frame_number = s->picture_number - 1; | |
8417 #endif | |
8418 return get_consumed_bytes(s, buf_index, buf_size); | |
8419 } | |
8420 #if 0 | |
8421 static inline void fill_mb_avail(H264Context *h){ | |
8422 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
|
8423 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8424 |
8425 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
|
8426 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
|
8427 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
|
8428 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8429 }else{ |
8430 h->mb_avail[0]= | |
8431 h->mb_avail[1]= | |
8432 h->mb_avail[2]= 0; | |
8433 } | |
8434 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8435 h->mb_avail[4]= 1; //FIXME move out | |
8436 h->mb_avail[5]= 0; //FIXME move out | |
8437 } | |
8438 #endif | |
8439 | |
8440 #if 0 //selftest | |
8441 #define COUNT 8000 | |
8442 #define SIZE (COUNT*40) | |
8443 int main(){ | |
8444 int i; | |
8445 uint8_t temp[SIZE]; | |
8446 PutBitContext pb; | |
8447 GetBitContext gb; | |
8448 // int int_temp[10000]; | |
8449 DSPContext dsp; | |
8450 AVCodecContext avctx; | |
2967 | 8451 |
1168 | 8452 dsputil_init(&dsp, &avctx); |
8453 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8454 init_put_bits(&pb, temp, SIZE); |
1168 | 8455 printf("testing unsigned exp golomb\n"); |
8456 for(i=0; i<COUNT; i++){ | |
8457 START_TIMER | |
8458 set_ue_golomb(&pb, i); | |
8459 STOP_TIMER("set_ue_golomb"); | |
8460 } | |
8461 flush_put_bits(&pb); | |
2967 | 8462 |
1168 | 8463 init_get_bits(&gb, temp, 8*SIZE); |
8464 for(i=0; i<COUNT; i++){ | |
8465 int j, s; | |
2967 | 8466 |
1168 | 8467 s= show_bits(&gb, 24); |
2967 | 8468 |
1168 | 8469 START_TIMER |
8470 j= get_ue_golomb(&gb); | |
8471 if(j != i){ | |
8472 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8473 // return -1; | |
8474 } | |
8475 STOP_TIMER("get_ue_golomb"); | |
8476 } | |
2967 | 8477 |
8478 | |
1524 | 8479 init_put_bits(&pb, temp, SIZE); |
1168 | 8480 printf("testing signed exp golomb\n"); |
8481 for(i=0; i<COUNT; i++){ | |
8482 START_TIMER | |
8483 set_se_golomb(&pb, i - COUNT/2); | |
8484 STOP_TIMER("set_se_golomb"); | |
8485 } | |
8486 flush_put_bits(&pb); | |
2967 | 8487 |
1168 | 8488 init_get_bits(&gb, temp, 8*SIZE); |
8489 for(i=0; i<COUNT; i++){ | |
8490 int j, s; | |
2967 | 8491 |
1168 | 8492 s= show_bits(&gb, 24); |
2967 | 8493 |
1168 | 8494 START_TIMER |
8495 j= get_se_golomb(&gb); | |
8496 if(j != i - COUNT/2){ | |
8497 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8498 // return -1; | |
8499 } | |
8500 STOP_TIMER("get_se_golomb"); | |
8501 } | |
8502 | |
8503 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8504 |
1168 | 8505 DCTELEM block[16]; |
8506 uint8_t src[16], ref[16]; | |
8507 uint64_t error= 0, max_error=0; | |
8508 | |
8509 for(i=0; i<COUNT; i++){ | |
8510 int j; | |
8511 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8512 for(j=0; j<16; j++){ | |
8513 ref[j]= random()%255; | |
8514 src[j]= random()%255; | |
8515 } | |
8516 | |
8517 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8518 |
1168 | 8519 //normalize |
8520 for(j=0; j<16; j++){ | |
8521 // printf("%d ", block[j]); | |
8522 block[j]= block[j]*4; | |
8523 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8524 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8525 } | |
8526 // printf("\n"); | |
2967 | 8527 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8528 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8529 /* for(j=0; j<16; j++){ |
8530 printf("%d ", ref[j]); | |
8531 } | |
8532 printf("\n");*/ | |
2967 | 8533 |
1168 | 8534 for(j=0; j<16; j++){ |
4001 | 8535 int diff= FFABS(src[j] - ref[j]); |
2967 | 8536 |
1168 | 8537 error+= diff*diff; |
8538 max_error= FFMAX(max_error, diff); | |
8539 } | |
8540 } | |
8541 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8542 #if 0 | |
8543 printf("testing quantizer\n"); | |
8544 for(qp=0; qp<52; qp++){ | |
8545 for(i=0; i<16; i++) | |
8546 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8547 |
1168 | 8548 } |
8549 #endif | |
8550 printf("Testing NAL layer\n"); | |
2967 | 8551 |
1168 | 8552 uint8_t bitstream[COUNT]; |
8553 uint8_t nal[COUNT*2]; | |
8554 H264Context h; | |
8555 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8556 |
1168 | 8557 for(i=0; i<COUNT; i++){ |
8558 int zeros= i; | |
8559 int nal_length; | |
8560 int consumed; | |
8561 int out_length; | |
8562 uint8_t *out; | |
8563 int j; | |
2967 | 8564 |
1168 | 8565 for(j=0; j<COUNT; j++){ |
8566 bitstream[j]= (random() % 255) + 1; | |
8567 } | |
2967 | 8568 |
1168 | 8569 for(j=0; j<zeros; j++){ |
8570 int pos= random() % COUNT; | |
8571 while(bitstream[pos] == 0){ | |
8572 pos++; | |
8573 pos %= COUNT; | |
8574 } | |
8575 bitstream[pos]=0; | |
8576 } | |
2967 | 8577 |
1168 | 8578 START_TIMER |
2967 | 8579 |
1168 | 8580 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8581 if(nal_length<0){ | |
8582 printf("encoding failed\n"); | |
8583 return -1; | |
8584 } | |
2967 | 8585 |
1168 | 8586 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8587 | |
8588 STOP_TIMER("NAL") | |
2967 | 8589 |
1168 | 8590 if(out_length != COUNT){ |
8591 printf("incorrect length %d %d\n", out_length, COUNT); | |
8592 return -1; | |
8593 } | |
2967 | 8594 |
1168 | 8595 if(consumed != nal_length){ |
8596 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8597 return -1; | |
8598 } | |
2967 | 8599 |
1168 | 8600 if(memcmp(bitstream, out, COUNT)){ |
8601 printf("missmatch\n"); | |
8602 return -1; | |
8603 } | |
8604 } | |
2967 | 8605 |
1168 | 8606 printf("Testing RBSP\n"); |
2967 | 8607 |
8608 | |
1168 | 8609 return 0; |
8610 } | |
8611 #endif | |
8612 | |
8613 | |
8614 static int decode_end(AVCodecContext *avctx) | |
8615 { | |
8616 H264Context *h = avctx->priv_data; | |
8617 MpegEncContext *s = &h->s; | |
2967 | 8618 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8619 av_freep(&h->rbsp_buffer); |
1168 | 8620 free_tables(h); //FIXME cleanup init stuff perhaps |
8621 MPV_common_end(s); | |
8622 | |
8623 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8624 |
1168 | 8625 return 0; |
8626 } | |
8627 | |
8628 | |
8629 AVCodec h264_decoder = { | |
8630 "h264", | |
8631 CODEC_TYPE_VIDEO, | |
8632 CODEC_ID_H264, | |
8633 sizeof(H264Context), | |
8634 decode_init, | |
8635 NULL, | |
8636 decode_end, | |
8637 decode_frame, | |
2453 | 8638 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8639 .flush= flush_dpb, |
1168 | 8640 }; |
8641 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8642 #ifdef CONFIG_H264_PARSER |
1988 | 8643 AVCodecParser h264_parser = { |
8644 { CODEC_ID_H264 }, | |
2392 | 8645 sizeof(H264Context), |
1988 | 8646 NULL, |
8647 h264_parse, | |
8648 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8649 h264_split, |
1988 | 8650 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8651 #endif |
1988 | 8652 |
1234 | 8653 #include "svq3.c" |