Mercurial > libavcodec.hg
annotate h264.c @ 4166:eced83504436 libavcodec
mp3 header (de)compression bitstream filter
this will make mp3 frames 4 bytes smaller, it will not give you binary identical mp3 files, but it will give you mp3 files which decode to binary identical output
this will only work in containers providing at least packet size, sample_rate and number of channels
bugreports about mp3 files for which this fails are welcome
and this is experimental (dont expect compatibility and dont even expect to be able to decompress what you compressed, hell dont even expect this to work without editing the source a little)
author | michael |
---|---|
date | Fri, 10 Nov 2006 01:41:53 +0000 |
parents | 171e768324cd |
children | 23da44e8fd05 |
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 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3152 static void decode_init_vlc(){ |
1168 | 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 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3409 decode_init_vlc(); |
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 } |
4042 | 6006 return get_cabac_bypass_sign( &h->cabac, -mvd ); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6007 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6008 |
2316 | 6009 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 6010 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
|
6011 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
|
6012 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6013 if( cat == 0 ) { |
2314 | 6014 nza = h->left_cbp&0x100; |
6015 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
|
6016 } else if( cat == 1 || cat == 2 ) { |
2314 | 6017 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
6018 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
|
6019 } else if( cat == 3 ) { |
2314 | 6020 nza = (h->left_cbp>>(6+idx))&0x01; |
6021 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
6022 } else { | |
6023 assert(cat == 4); | |
6024 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
6025 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
6026 } | |
6027 | |
6028 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
|
6029 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6030 |
2314 | 6031 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
|
6032 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
|
6033 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6034 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
|
6035 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6036 |
4051 | 6037 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
6038 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
6039 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
6040 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
6041 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
6042 }; | |
6043 | |
3028 | 6044 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
|
6045 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 6046 static const int significant_coeff_flag_offset[2][6] = { |
6047 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
6048 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
6049 }; | |
6050 static const int last_coeff_flag_offset[2][6] = { | |
6051 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
6052 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
6053 }; | |
6054 static const int coeff_abs_level_m1_offset[6] = { | |
6055 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
6056 }; | |
4007 | 6057 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 6058 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 6059 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
6060 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 6061 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
6062 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
6063 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
6064 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
6065 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 6066 }; |
6067 | |
6068 int index[64]; | |
2313 | 6069 |
4041
0113ceb0f953
1 variable less in decode_cabac_residual() no speed change (but less vars means less things gcc can load and store redundantly)
michael
parents:
4040
diff
changeset
|
6070 int last; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
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]; |
4113
4ce3923d5806
Reenable AMD64 optimizations for cabac accidentially disabled in r6852
reimar
parents:
4112
diff
changeset
|
6142 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6143 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6144 } else { | |
6145 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6146 #else | |
3316 | 6147 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6148 } else { |
6149 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
|
6150 #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
|
6151 } |
2316 | 6152 assert(coeff_count > 0); |
6153 | |
6154 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
|
6155 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
|
6156 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
|
6157 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6158 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
|
6159 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6160 else if( cat == 4 ) |
6161 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6162 else { |
2755 | 6163 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6164 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6165 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6166 |
4041
0113ceb0f953
1 variable less in decode_cabac_residual() no speed change (but less vars means less things gcc can load and store redundantly)
michael
parents:
4040
diff
changeset
|
6167 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6168 uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base; |
4041
0113ceb0f953
1 variable less in decode_cabac_residual() no speed change (but less vars means less things gcc can load and store redundantly)
michael
parents:
4040
diff
changeset
|
6169 int j= scantable[index[coeff_count]]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6170 |
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
|
6171 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6172 if( !qmul ) { |
4040 | 6173 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6174 }else{ |
4040 | 6175 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6176 } |
2967 | 6177 |
2313 | 6178 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
|
6179 } else { |
2313 | 6180 int coeff_abs = 2; |
2898 | 6181 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
|
6182 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6183 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
|
6184 } |
2313 | 6185 |
6186 if( coeff_abs >= 15 ) { | |
6187 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
|
6188 while( get_cabac_bypass( CC ) ) { |
2313 | 6189 j++; |
6190 } | |
2967 | 6191 |
4016 | 6192 coeff_abs=1; |
2313 | 6193 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
|
6194 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6195 } |
4016 | 6196 coeff_abs+= 14; |
2313 | 6197 } |
6198 | |
2898 | 6199 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
|
6200 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6201 else block[j] = coeff_abs; |
6202 }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
|
6203 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6204 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6205 } |
2967 | 6206 |
2313 | 6207 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
|
6208 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6209 } |
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
|
6210 #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
|
6211 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
|
6212 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
|
6213 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
|
6214 #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
|
6215 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
|
6216 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6217 |
3077 | 6218 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
|
6219 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6220 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
|
6221 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
|
6222 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
|
6223 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6224 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
|
6225 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
|
6226 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
|
6227 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
|
6228 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6229 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
|
6230 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
|
6231 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6232 ? !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
|
6233 : (!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
|
6234 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6235 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
|
6236 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6237 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
|
6238 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
|
6239 } |
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 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6242 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6243 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6244 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6245 * 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
|
6246 * @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
|
6247 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6248 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
|
6249 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
|
6250 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
|
6251 int mb_type, partition_count, cbp = 0; |
2755 | 6252 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
|
6253 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6254 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
|
6255 |
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
|
6256 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
|
6257 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6258 int skip; |
6259 /* a skipped mb needs the aff flag from the following mb */ | |
6260 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6261 predict_field_decoding_flag(h); | |
6262 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6263 skip = h->next_mb_skipped; | |
6264 else | |
6265 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
|
6266 /* read skip flags */ |
3316 | 6267 if( skip ) { |
6268 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6269 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6270 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6271 if(h->next_mb_skipped) | |
6272 predict_field_decoding_flag(h); | |
6273 else | |
6274 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6275 } | |
6276 | |
2396 | 6277 decode_mb_skip(h); |
6278 | |
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->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
|
6280 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
|
6281 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
|
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 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
|
6284 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6285 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6286 } |
3316 | 6287 if(FRAME_MBAFF){ |
6288 if( (s->mb_y&1) == 0 ) | |
6289 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
|
6290 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
|
6291 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6292 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
|
6293 |
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
|
6294 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
|
6295 |
3077 | 6296 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
|
6297 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
|
6298 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
|
6299 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
|
6300 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6301 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6302 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
|
6303 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
|
6304 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
|
6305 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
|
6306 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6307 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
|
6308 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
|
6309 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6310 } 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
|
6311 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
|
6312 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
|
6313 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
|
6314 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6315 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
|
6316 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
|
6317 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6318 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6319 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
|
6320 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
|
6321 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
|
6322 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
|
6323 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
|
6324 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
|
6325 } |
3316 | 6326 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
|
6327 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
|
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 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
|
6330 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6331 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6332 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6333 unsigned int x, y; |
2967 | 6334 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6335 // 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
|
6336 // 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
|
6337 // 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
|
6338 ptr= h->cabac.bytestream; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6339 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
|
6340 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6341 // 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
|
6342 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6343 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
|
6344 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6345 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6346 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
|
6347 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6348 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6349 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6350 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
|
6351 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6352 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
|
6353 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
|
6354 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6355 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6356 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6357 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
|
6358 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6359 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
|
6360 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
|
6361 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6362 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6363 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6364 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
|
6365 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6366 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6367 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
|
6368 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
|
6369 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6370 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
|
6371 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
|
6372 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6373 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6374 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
|
6375 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
|
6376 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6377 |
3316 | 6378 if(MB_MBAFF){ |
6379 h->ref_count[0] <<= 1; | |
6380 h->ref_count[1] <<= 1; | |
6381 } | |
6382 | |
2449 | 6383 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
|
6384 |
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_INTRA( mb_type ) ) { |
2755 | 6386 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
|
6387 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6388 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6389 mb_type |= MB_TYPE_8x8DCT; | |
6390 for( i = 0; i < 16; i+=4 ) { | |
6391 int pred = pred_intra_mode( h, i ); | |
6392 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6393 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6394 } | |
6395 } else { | |
6396 for( i = 0; i < 16; i++ ) { | |
6397 int pred = pred_intra_mode( h, i ); | |
6398 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
|
6399 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6400 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6401 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6402 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6403 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
|
6404 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
|
6405 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6406 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
|
6407 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
|
6408 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6409 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
|
6410 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
|
6411 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6412 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
|
6413 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
|
6414 } 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
|
6415 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
|
6416 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6417 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
|
6418 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
|
6419 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
|
6420 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
|
6421 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
|
6422 } |
3482 | 6423 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6424 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6425 pred_direct_motion(h, &mb_type); |
6426 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6427 for( i = 0; i < 4; i++ ) | |
6428 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6429 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6430 } | |
6431 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6432 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6433 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
|
6434 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
|
6435 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
|
6436 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
|
6437 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6438 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6439 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6440 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
|
6441 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
|
6442 for( i = 0; i < 4; i++ ) { |
2396 | 6443 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6444 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
|
6445 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
|
6446 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
|
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] = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6449 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6450 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
|
6451 } |
2110 | 6452 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
|
6453 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
|
6454 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6455 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6456 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6457 |
2755 | 6458 if(dct8x8_allowed) |
6459 dct8x8_allowed = get_dct8x8_allowed(h); | |
6460 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6461 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
|
6462 for(i=0; i<4; i++){ |
2396 | 6463 if(IS_DIRECT(h->sub_mb_type[i])){ |
6464 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6465 continue; | |
6466 } | |
2110 | 6467 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
|
6468 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6469 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
|
6470 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
|
6471 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
|
6472 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
|
6473 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
|
6474 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
|
6475 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
|
6476 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
|
6477 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
|
6478 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
|
6479 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6480 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
|
6481 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
|
6482 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
|
6483 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6484 if(IS_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
|
6485 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
|
6486 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
|
6487 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
|
6488 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
|
6489 |
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 ][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
|
6491 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
|
6492 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
|
6493 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
|
6494 }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
|
6495 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
|
6496 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
|
6497 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6498 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
|
6499 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
|
6500 }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
|
6501 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
|
6502 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
|
6503 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6504 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
|
6505 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
|
6506 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6507 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
|
6508 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
|
6509 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
|
6510 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6511 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
|
6512 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
|
6513 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6514 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6515 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6516 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
|
6517 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
|
6518 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
|
6519 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
|
6520 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6521 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6522 } |
2396 | 6523 } else if( IS_DIRECT(mb_type) ) { |
6524 pred_direct_motion(h, &mb_type); | |
6525 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6526 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6527 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6528 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6529 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
|
6530 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
|
6531 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
|
6532 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
|
6533 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
|
6534 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
|
6535 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
|
6536 } |
2523 | 6537 }else |
6538 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
|
6539 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6540 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
|
6541 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
|
6542 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
|
6543 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6544 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
|
6545 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
|
6546 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
|
6547 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6548 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
|
6549 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6550 }else |
6551 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
|
6552 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6553 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6554 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
|
6555 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
|
6556 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
|
6557 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6558 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6559 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
|
6560 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6561 }else |
6562 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
|
6563 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6564 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6565 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6566 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
|
6567 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
|
6568 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
|
6569 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
|
6570 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
|
6571 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
|
6572 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
|
6573 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6574 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
|
6575 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6576 }else{ |
2396 | 6577 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6578 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
|
6579 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6580 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6581 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6582 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6583 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
|
6584 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
|
6585 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
|
6586 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
|
6587 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
|
6588 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
|
6589 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6590 }else |
6591 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
|
6592 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6593 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6594 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6595 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
|
6596 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
|
6597 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
|
6598 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
|
6599 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
|
6600 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
|
6601 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6602 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
|
6603 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
|
6604 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6605 }else{ |
2396 | 6606 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6607 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
|
6608 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6609 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6610 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6611 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6612 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6613 |
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
|
6614 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
|
6615 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
|
6616 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
|
6617 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6618 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6619 if( !IS_INTRA16x16( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6620 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
|
6621 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
|
6622 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6623 |
3651 | 6624 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
|
6625 |
2755 | 6626 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6627 if( decode_cabac_mb_transform_size( h ) ) | |
6628 mb_type |= MB_TYPE_8x8DCT; | |
6629 } | |
6630 s->current_picture.mb_type[mb_xy]= mb_type; | |
6631 | |
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 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6633 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
|
6634 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
|
6635 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6636 if(IS_INTERLACED(mb_type)){ |
3316 | 6637 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6638 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
|
6639 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
|
6640 }else{ |
3316 | 6641 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6642 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
|
6643 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
|
6644 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6645 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6646 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
|
6647 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6648 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
|
6649 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6650 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6651 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
|
6652 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
|
6653 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
|
6654 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
|
6655 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6656 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
|
6657 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6658 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
|
6659 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
|
6660 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6661 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
|
6662 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6663 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
|
6664 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
|
6665 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6666 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
|
6667 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
|
6668 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6669 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6670 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
|
6671 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6672 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6673 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
|
6674 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
|
6675 if( cbp & (1<<i8x8) ) { |
2755 | 6676 if( IS_8x8DCT(mb_type) ) { |
6677 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6678 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6679 return -1; |
6680 } 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
|
6681 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
|
6682 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
|
6683 //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
|
6684 //START_TIMER |
2919 | 6685 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
|
6686 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6687 //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
|
6688 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6689 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6690 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
|
6691 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6695 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6696 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
|
6697 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
|
6698 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
|
6699 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6700 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
|
6701 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6704 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6705 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
|
6706 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
|
6707 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
|
6708 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
|
6709 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
|
6710 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6711 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
|
6712 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
|
6713 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6714 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6715 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6716 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
|
6717 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
|
6718 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
|
6719 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6720 } else { |
2315 | 6721 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6722 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6723 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6724 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6725 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
|
6726 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6727 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6728 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
|
6729 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
|
6730 |
3316 | 6731 if(MB_MBAFF){ |
6732 h->ref_count[0] >>= 1; | |
6733 h->ref_count[1] >>= 1; | |
6734 } | |
6735 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6736 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
|
6737 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6738 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6739 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6740 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
|
6741 int i, d; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6742 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6743 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6744 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6745 |
2633 | 6746 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
|
6747 int8_t tc[4]; |
2633 | 6748 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6749 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6750 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6751 } else { | |
6752 /* 16px edge length, because bS=4 is triggered by being at | |
6753 * the edge of an intra MB, so all 4 bS are the same */ | |
6754 for( d = 0; d < 16; d++ ) { | |
1898 | 6755 const int p0 = pix[-1]; |
6756 const int p1 = pix[-2]; | |
6757 const int p2 = pix[-3]; | |
6758 | |
6759 const int q0 = pix[0]; | |
6760 const int q1 = pix[1]; | |
6761 const int q2 = pix[2]; | |
6762 | |
4001 | 6763 if( FFABS( p0 - q0 ) < alpha && |
6764 FFABS( p1 - p0 ) < beta && | |
6765 FFABS( q1 - q0 ) < beta ) { | |
6766 | |
6767 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6768 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6769 { |
6770 const int p3 = pix[-4]; | |
6771 /* p0', p1', p2' */ | |
6772 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6773 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6774 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6775 } else { | |
6776 /* p0' */ | |
6777 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6778 } | |
4001 | 6779 if( FFABS( q2 - q0 ) < beta) |
1898 | 6780 { |
6781 const int q3 = pix[3]; | |
6782 /* q0', q1', q2' */ | |
6783 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6784 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6785 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6786 } else { | |
6787 /* q0' */ | |
6788 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6789 } | |
6790 }else{ | |
6791 /* p0', q0' */ | |
6792 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6793 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6794 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6795 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
|
6796 } |
1898 | 6797 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
|
6798 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6799 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6800 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6801 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6802 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6803 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6804 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6805 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6806 |
2633 | 6807 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
|
6808 int8_t tc[4]; |
2633 | 6809 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6810 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6811 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6812 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6813 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
|
6814 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6815 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6816 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6817 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
|
6818 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6819 for( i = 0; i < 16; i++, pix += stride) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6820 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6821 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6822 int beta; |
2967 | 6823 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6824 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6825 int bS_index = (i >> 1); |
3316 | 6826 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6827 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6829 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6830 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6831 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6832 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6833 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6834 |
3316 | 6835 qp_index = MB_FIELD ? (i >> 3) : (i & 1); |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6836 index_a = qp[qp_index] + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6837 alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6838 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6839 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6840 if( bS[bS_index] < 4 ) { |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6841 const int tc0 = (tc0_table+52)[index_a][bS[bS_index] - 1]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6842 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6843 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6844 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6845 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6847 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6848 |
4001 | 6849 if( FFABS( p0 - q0 ) < alpha && |
6850 FFABS( p1 - p0 ) < beta && | |
6851 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6852 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6853 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6854 |
4001 | 6855 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6856 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
|
6857 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6858 } |
4001 | 6859 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6860 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
|
6861 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6862 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6863 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6864 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
|
6865 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
|
6866 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
|
6867 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
|
6868 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6869 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6870 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6871 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6872 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6873 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6874 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6875 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6876 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6877 |
4001 | 6878 if( FFABS( p0 - q0 ) < alpha && |
6879 FFABS( p1 - p0 ) < beta && | |
6880 FFABS( q1 - q0 ) < beta ) { | |
6881 | |
6882 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6883 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6884 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6885 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6886 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6887 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
|
6888 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
|
6889 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
|
6890 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6891 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6892 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
|
6893 } |
4001 | 6894 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6895 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6896 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6897 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6898 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
|
6899 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
|
6900 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
|
6901 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6902 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6903 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
|
6904 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6905 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6906 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6907 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
|
6908 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
|
6909 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6910 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
|
6911 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6912 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6913 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6914 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6915 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
|
6916 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6917 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
|
6918 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6919 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6920 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6921 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6922 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6923 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6924 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6925 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6926 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6927 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6928 |
3316 | 6929 qp_index = MB_FIELD ? (i >> 2) : (i & 1); |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6930 index_a = qp[qp_index] + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6931 alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6932 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6933 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6934 if( bS[bS_index] < 4 ) { |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6935 const int tc = (tc0_table+52)[index_a][bS[bS_index] - 1] + 1; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6936 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6937 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6938 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6939 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6940 |
4001 | 6941 if( FFABS( p0 - q0 ) < alpha && |
6942 FFABS( p1 - p0 ) < beta && | |
6943 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6944 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
|
6945 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6946 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
|
6947 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
|
6948 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
|
6949 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6950 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6951 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6952 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6953 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6954 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6955 |
4001 | 6956 if( FFABS( p0 - q0 ) < alpha && |
6957 FFABS( p1 - p0 ) < beta && | |
6958 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6959 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6960 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
|
6961 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
|
6962 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
|
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 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6966 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6967 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6968 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
|
6969 int i, d; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6970 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6971 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6972 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6973 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
|
6974 |
2633 | 6975 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
|
6976 int8_t tc[4]; |
2633 | 6977 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6978 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6979 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6980 } else { | |
6981 /* 16px edge length, see filter_mb_edgev */ | |
6982 for( d = 0; d < 16; d++ ) { | |
1898 | 6983 const int p0 = pix[-1*pix_next]; |
6984 const int p1 = pix[-2*pix_next]; | |
6985 const int p2 = pix[-3*pix_next]; | |
6986 const int q0 = pix[0]; | |
6987 const int q1 = pix[1*pix_next]; | |
6988 const int q2 = pix[2*pix_next]; | |
6989 | |
4001 | 6990 if( FFABS( p0 - q0 ) < alpha && |
6991 FFABS( p1 - p0 ) < beta && | |
6992 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6993 |
6994 const int p3 = pix[-4*pix_next]; | |
6995 const int q3 = pix[ 3*pix_next]; | |
6996 | |
4001 | 6997 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6998 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6999 /* p0', p1', p2' */ |
7000 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
7001 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
7002 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
7003 } else { | |
7004 /* p0' */ | |
7005 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
7006 } | |
4001 | 7007 if( FFABS( q2 - q0 ) < beta) { |
1898 | 7008 /* q0', q1', q2' */ |
7009 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
7010 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
7011 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
7012 } else { | |
7013 /* q0' */ | |
7014 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
7015 } | |
7016 }else{ | |
7017 /* p0', q0' */ | |
7018 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
7019 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
7020 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7021 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
|
7022 } |
1898 | 7023 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
|
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 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7026 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7027 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7028 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 7029 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
7030 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
7031 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
7032 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7033 |
2633 | 7034 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
|
7035 int8_t tc[4]; |
2633 | 7036 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
7037 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 7038 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
7039 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
7040 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
|
7041 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7042 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7043 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 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
|
7045 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7046 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7047 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7048 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7049 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
|
7050 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
|
7051 return; |
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 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7054 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7055 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7056 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7057 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7058 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7059 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7060 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7061 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7062 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7063 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7064 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7065 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7066 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 7067 qp_thresh = 15 - h->slice_alpha_c0_offset; |
7068 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
7069 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
7070 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7071 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7072 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7073 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7074 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7075 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7076 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7077 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7078 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7079 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7080 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7081 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7082 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7083 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7084 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7085 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7086 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7087 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7088 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7089 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7090 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7091 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7092 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7093 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7094 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7095 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7096 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7097 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7098 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7099 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7100 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7101 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7102 int edges; |
7103 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7104 edges = 4; | |
7105 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7106 } else { | |
7107 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7108 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7109 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7110 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7111 ? 3 : 0; | |
7112 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7113 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7114 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7115 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7116 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7117 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7118 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7119 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7120 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7121 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7122 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7123 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7124 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
|
7125 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7126 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
|
7127 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
|
7128 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7129 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7130 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7131 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7132 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7133 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7134 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7135 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7136 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7137 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7138 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7139 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7140 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7141 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7142 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7143 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7144 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7145 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7146 FILTER(h,1,3); |
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 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7149 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7150 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7151 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7152 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
|
7153 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
|
7154 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7155 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7156 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
|
7157 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
|
7158 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7159 /* 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
|
7160 * 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
|
7161 * frame numbers, not indices. */ |
3316 | 7162 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7163 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
|
7164 |
3101 | 7165 //for sufficiently low qp, filtering wouldn't do anything |
7166 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7167 if(!FRAME_MBAFF){ |
3101 | 7168 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7169 int qp = s->current_picture.qscale_table[mb_xy]; | |
7170 if(qp <= qp_thresh | |
7171 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7172 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7173 return; | |
7174 } | |
7175 } | |
7176 | |
3316 | 7177 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7178 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7179 && 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
|
7180 // and current and left pair do not have the same interlaced type |
3316 | 7181 && (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
|
7182 // 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
|
7183 && (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
|
7184 /* 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
|
7185 * 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
|
7186 */ |
3316 | 7187 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7188 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
|
7189 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7190 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7191 int chroma_qp[2]; |
3316 | 7192 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
|
7193 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7194 first_vertical_edge_done = 1; |
3316 | 7195 |
7196 if( IS_INTRA(mb_type) ) | |
7197 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7198 else { | |
7199 for( i = 0; i < 8; i++ ) { | |
7200 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7201 | |
7202 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7203 bS[i] = 4; | |
7204 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7205 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7206 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7207 bS[i] = 2; | |
7208 else | |
7209 bS[i] = 1; | |
7210 } | |
7211 } | |
7212 | |
7213 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7214 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7215 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7216 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7217 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7218 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7219 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7220 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7221 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7222 | |
7223 /* Filter edge */ | |
7224 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); | |
7225 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7226 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7227 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7228 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
|
7229 } |
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
|
7230 /* 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
|
7231 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
|
7232 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7233 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7234 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7235 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7236 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7237 | |
3101 | 7238 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7239 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7240 // how often to recheck mv-based bS when iterating between edges |
7241 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7242 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7243 // how often to recheck mv-based bS when iterating along each edge | |
7244 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7245 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7246 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7247 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7248 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7249 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7250 |
2454 | 7251 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
|
7252 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
|
7253 |
3316 | 7254 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7255 && !IS_INTERLACED(mb_type) | |
7256 && IS_INTERLACED(mbm_type) | |
7257 ) { | |
7258 // This is a special case in the norm where the filtering must | |
7259 // be done twice (one each of the field) even if we are in a | |
7260 // frame macroblock. | |
7261 // | |
7262 static const int nnz_idx[4] = {4,5,6,3}; | |
7263 unsigned int tmp_linesize = 2 * linesize; | |
7264 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7265 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7266 int qp, chroma_qp; | |
7267 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7268 int16_t bS[4]; |
3316 | 7269 |
7270 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7271 if( IS_INTRA(mb_type) || | |
7272 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7273 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7274 } else { | |
7275 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7276 for( i = 0; i < 4; i++ ) { | |
7277 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7278 mbn_nnz[nnz_idx[i]] != 0 ) | |
7279 bS[i] = 2; | |
7280 else | |
7281 bS[i] = 1; | |
7282 } | |
7283 } | |
7284 // Do not use s->qscale as luma quantizer because it has not the same | |
7285 // value in IPCM macroblocks. | |
7286 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7287 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); | |
7288 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7289 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7290 chroma_qp = ( h->chroma_qp + | |
7291 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7292 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7293 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7294 } | |
7295 | |
7296 start = 1; | |
7297 } | |
7298 | |
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
|
7299 /* Calculate bS */ |
2924 | 7300 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7301 /* mbn_xy: neighbor macroblock */ |
2924 | 7302 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7303 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7304 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
|
7305 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
|
7306 |
2924 | 7307 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7308 continue; |
7309 | |
2924 | 7310 if( IS_INTRA(mb_type) || |
7311 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7312 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7313 if (edge == 0) { |
2924 | 7314 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7315 || ((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
|
7316 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7317 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7318 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7319 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7320 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7321 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7322 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7323 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7324 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
|
7325 } else { |
2924 | 7326 int i, l; |
7327 int mv_done; | |
7328 | |
7329 if( edge & mask_edge ) { | |
7330 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7331 mv_done = 1; | |
7332 } | |
3316 | 7333 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7334 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7335 mv_done = 1; | |
7336 } | |
2924 | 7337 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7338 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7339 int bn_idx= b_idx - (dir ? 8:1); | |
7340 int v = 0; | |
7341 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7342 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7343 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7344 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7345 } |
7346 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7347 mv_done = 1; | |
7348 } | |
7349 else | |
7350 mv_done = 0; | |
7351 | |
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
|
7352 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
|
7353 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
|
7354 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
|
7355 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
|
7356 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
|
7357 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7358 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7359 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
|
7360 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
|
7361 } |
2924 | 7362 else if(!mv_done) |
2523 | 7363 { |
7364 bS[i] = 0; | |
7365 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
|
7366 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7367 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7368 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7369 bS[i] = 1; |
7370 break; | |
7371 } | |
7372 } | |
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
|
7373 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7374 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7375 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7376 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
|
7377 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
|
7378 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7379 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7380 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7381 // 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
|
7382 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7383 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
|
7384 //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
|
7385 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
|
7386 { 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
|
7387 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
|
7388 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7389 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
|
7390 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
|
7391 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
|
7392 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
|
7393 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
|
7394 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7395 } 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
|
7396 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7397 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
|
7398 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
|
7399 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
|
7400 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
|
7401 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
|
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 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7406 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7407 |
1168 | 7408 static int decode_slice(H264Context *h){ |
7409 MpegEncContext * const s = &h->s; | |
7410 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7411 | |
7412 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
|
7413 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7414 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
|
7415 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
|
7416 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7417 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7418 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
|
7419 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7420 /* 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
|
7421 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
|
7422 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
|
7423 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7424 ( 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
|
7425 /* calculate pre-state */ |
2755 | 7426 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
|
7427 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
|
7428 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
|
7429 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
|
7430 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7431 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
|
7432 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7433 if( pre <= 63 ) |
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 * ( 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
|
7435 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7436 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7437 } |
7438 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7439 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7440 //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
|
7441 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
|
7442 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
|
7443 //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
|
7444 |
2163 | 7445 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
|
7446 |
3316 | 7447 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
|
7448 s->mb_y++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7449 |
2163 | 7450 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
|
7451 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7452 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
|
7453 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
|
7454 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7455 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
|
7456 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7457 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
|
7458 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
|
7459 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
|
7460 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
|
7461 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7462 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7463 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
|
7464 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
|
7465 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7466 ++s->mb_y; |
3316 | 7467 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7468 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7469 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7470 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7471 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7472 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7473 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
|
7474 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
|
7475 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
|
7476 } |
1168 | 7477 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7478 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7479 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7480 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7481 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
|
7482 |
2163 | 7483 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
|
7484 |
3316 | 7485 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
|
7486 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
|
7487 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
|
7488 |
2163 | 7489 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
|
7490 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
|
7491 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7492 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7493 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
|
7494 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
|
7495 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
|
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 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
|
7498 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7499 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7500 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
|
7501 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
|
7502 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
|
7503 ++s->mb_y; |
3316 | 7504 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7505 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7506 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7507 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
|
7508 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
|
7509 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7510 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
|
7511 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
|
7512 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7513 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
|
7514 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7515 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
|
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 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7521 |
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 && s->mb_skip_run<=0){ |
2392 | 7523 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
|
7524 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7525 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); |
7526 | |
7527 return 0; | |
7528 }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
|
7529 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 | 7530 |
7531 return -1; | |
7532 } | |
7533 } | |
7534 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7535 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7536 |
1168 | 7537 #if 0 |
7538 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7539 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7540 int ret= decode_mb(h); | |
2967 | 7541 |
1168 | 7542 hl_decode_mb(h); |
7543 | |
7544 if(ret<0){ | |
3177 | 7545 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7546 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); |
7547 | |
7548 return -1; | |
7549 } | |
2967 | 7550 |
1168 | 7551 if(++s->mb_x >= s->mb_width){ |
7552 s->mb_x=0; | |
7553 if(++s->mb_y >= s->mb_height){ | |
7554 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7555 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); | |
7556 | |
7557 return 0; | |
7558 }else{ | |
7559 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); | |
7560 | |
7561 return -1; | |
7562 } | |
7563 } | |
7564 } | |
2967 | 7565 |
1168 | 7566 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7567 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7568 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); | |
7569 | |
7570 return 0; | |
7571 }else{ | |
7572 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); | |
7573 | |
7574 return -1; | |
7575 } | |
7576 } | |
7577 } | |
7578 s->mb_x=0; | |
7579 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7580 } | |
7581 #endif | |
7582 return -1; //not reached | |
7583 } | |
7584 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7585 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
|
7586 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7587 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7588 int e, build, i; |
2967 | 7589 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7590 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7591 return -1; |
2967 | 7592 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7593 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
|
7594 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
|
7595 } |
2967 | 7596 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7597 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7598 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
|
7599 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7600 h->x264_build= build; |
2967 | 7601 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7602 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
|
7603 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
|
7604 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7605 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7606 skip_bits(&s->gb, 8); |
2967 | 7607 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7608 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7609 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7610 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7611 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7612 MpegEncContext * const s = &h->s; |
2967 | 7613 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7614 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
|
7615 int size, type; |
2967 | 7616 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7617 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7618 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7619 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7620 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7621 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7622 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7623 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7624 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7625 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7626 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7627 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7628 case 5: |
3318 | 7629 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
|
7630 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7631 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7632 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7633 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7634 } |
2967 | 7635 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7636 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7637 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7638 } |
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 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7641 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7642 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7643 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
|
7644 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7645 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7646 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
|
7647 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
|
7648 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
|
7649 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
|
7650 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
|
7651 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
|
7652 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
|
7653 } |
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); /* 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
|
7655 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
|
7656 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
|
7657 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
|
7658 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7659 |
1168 | 7660 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7661 MpegEncContext * const s = &h->s; | |
7662 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
|
7663 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7664 |
7665 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7666 |
1168 | 7667 if( aspect_ratio_info_present_flag ) { |
7668 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7669 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7670 sps->sar.num= get_bits(&s->gb, 16); |
7671 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
|
7672 }else if(aspect_ratio_idc < 14){ |
1548 | 7673 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7674 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7675 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7676 return -1; |
7677 } | |
7678 }else{ | |
2967 | 7679 sps->sar.num= |
1548 | 7680 sps->sar.den= 0; |
1168 | 7681 } |
7682 // 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
|
7683 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7684 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
|
7685 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
|
7686 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7687 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7688 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
|
7689 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
|
7690 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
|
7691 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
|
7692 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
|
7693 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
|
7694 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
|
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 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7697 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7698 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
|
7699 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
|
7700 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
|
7701 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7702 |
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->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
|
7704 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
|
7705 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
|
7706 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
|
7707 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
|
7708 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7709 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7710 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
|
7711 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
|
7712 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7713 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
|
7714 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
|
7715 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7716 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
|
7717 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
|
7718 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
|
7719 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7720 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
|
7721 if(sps->bitstream_restriction_flag){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7722 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
|
7723 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
|
7724 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
|
7725 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
|
7726 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
|
7727 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
|
7728 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
|
7729 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7730 |
1168 | 7731 return 0; |
7732 } | |
7733 | |
3004 | 7734 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7735 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7736 MpegEncContext * const s = &h->s; |
7737 int i, last = 8, next = 8; | |
7738 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7739 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7740 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7741 else |
7742 for(i=0;i<size;i++){ | |
7743 if(next) | |
7744 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7745 if(!i && !next){ /* matrix not written, we use the preset one */ |
7746 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7747 break; |
7748 } | |
7749 last = factors[scan[i]] = next ? next : last; | |
7750 } | |
7751 } | |
7752 | |
7753 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7754 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7755 MpegEncContext * const s = &h->s; | |
7756 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7757 const uint8_t *fallback[4] = { | |
7758 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7759 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7760 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7761 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7762 }; | |
7763 if(get_bits1(&s->gb)){ | |
7764 sps->scaling_matrix_present |= is_sps; | |
3004 | 7765 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7766 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7767 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7768 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7769 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7770 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7771 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7772 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7773 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7774 } |
7775 } else if(fallback_sps) { | |
7776 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7777 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7778 } | |
7779 } | |
7780 | |
1168 | 7781 static inline int decode_seq_parameter_set(H264Context *h){ |
7782 MpegEncContext * const s = &h->s; | |
1371 | 7783 int profile_idc, level_idc; |
1168 | 7784 int sps_id, i; |
7785 SPS *sps; | |
2967 | 7786 |
1168 | 7787 profile_idc= get_bits(&s->gb, 8); |
1371 | 7788 get_bits1(&s->gb); //constraint_set0_flag |
7789 get_bits1(&s->gb); //constraint_set1_flag | |
7790 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7791 get_bits1(&s->gb); //constraint_set3_flag |
7792 get_bits(&s->gb, 4); // reserved | |
1168 | 7793 level_idc= get_bits(&s->gb, 8); |
7794 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7795 |
1168 | 7796 sps= &h->sps_buffer[ sps_id ]; |
7797 sps->profile_idc= profile_idc; | |
7798 sps->level_idc= level_idc; | |
2312 | 7799 |
2755 | 7800 if(sps->profile_idc >= 100){ //high profile |
7801 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7802 get_bits1(&s->gb); //residual_color_transform_flag | |
7803 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7804 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7805 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7806 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7807 }else | |
7808 sps->scaling_matrix_present = 0; | |
2755 | 7809 |
1168 | 7810 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7811 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7812 |
1168 | 7813 if(sps->poc_type == 0){ //FIXME #define |
7814 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7815 } else if(sps->poc_type == 1){//FIXME #define | |
7816 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7817 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7818 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
7819 sps->poc_cycle_length= get_ue_golomb(&s->gb); | |
2967 | 7820 |
1168 | 7821 for(i=0; i<sps->poc_cycle_length; i++) |
7822 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
7823 } | |
7824 if(sps->poc_type > 2){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7825 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7826 return -1; |
7827 } | |
7828 | |
7829 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
|
7830 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
|
7831 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
|
7832 } |
1371 | 7833 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
1168 | 7834 sps->mb_width= get_ue_golomb(&s->gb) + 1; |
7835 sps->mb_height= get_ue_golomb(&s->gb) + 1; | |
2967 | 7836 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 || |
2422 | 7837 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)) |
7838 return -1; | |
7839 | |
1168 | 7840 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7841 if(!sps->frame_mbs_only_flag) | |
7842 sps->mb_aff= get_bits1(&s->gb); | |
7843 else | |
7844 sps->mb_aff= 0; | |
7845 | |
7846 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7847 | |
3316 | 7848 #ifndef ALLOW_INTERLACE |
7849 if(sps->mb_aff) | |
3954 | 7850 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7851 #endif |
7852 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7853 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7854 | |
1371 | 7855 sps->crop= get_bits1(&s->gb); |
7856 if(sps->crop){ | |
7857 sps->crop_left = get_ue_golomb(&s->gb); | |
7858 sps->crop_right = get_ue_golomb(&s->gb); | |
7859 sps->crop_top = get_ue_golomb(&s->gb); | |
7860 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7861 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
|
7862 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7863 } |
7864 }else{ | |
2967 | 7865 sps->crop_left = |
7866 sps->crop_right = | |
7867 sps->crop_top = | |
1371 | 7868 sps->crop_bottom= 0; |
7869 } | |
7870 | |
1168 | 7871 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7872 if( sps->vui_parameters_present_flag ) | |
7873 decode_vui_parameters(h, sps); | |
2967 | 7874 |
1168 | 7875 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 7876 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 | 7877 sps_id, sps->profile_idc, sps->level_idc, |
7878 sps->poc_type, | |
7879 sps->ref_frame_count, | |
7880 sps->mb_width, sps->mb_height, | |
7881 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7882 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7883 sps->crop_left, sps->crop_right, |
7884 sps->crop_top, sps->crop_bottom, | |
1168 | 7885 sps->vui_parameters_present_flag ? "VUI" : "" |
7886 ); | |
7887 } | |
7888 return 0; | |
7889 } | |
7890 | |
2755 | 7891 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7892 MpegEncContext * const s = &h->s; |
7893 int pps_id= get_ue_golomb(&s->gb); | |
7894 PPS *pps= &h->pps_buffer[pps_id]; | |
2967 | 7895 |
1168 | 7896 pps->sps_id= get_ue_golomb(&s->gb); |
7897 pps->cabac= get_bits1(&s->gb); | |
7898 pps->pic_order_present= get_bits1(&s->gb); | |
7899 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7900 if(pps->slice_group_count > 1 ){ | |
7901 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
|
7902 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7903 switch(pps->mb_slice_group_map_type){ |
7904 case 0: | |
7905 #if 0 | |
7906 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7907 | run_length[ i ] |1 |ue(v) | | |
7908 #endif | |
7909 break; | |
7910 case 2: | |
7911 #if 0 | |
7912 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7913 |{ | | | | |
7914 | top_left_mb[ i ] |1 |ue(v) | | |
7915 | bottom_right_mb[ i ] |1 |ue(v) | | |
7916 | } | | | | |
7917 #endif | |
7918 break; | |
7919 case 3: | |
7920 case 4: | |
7921 case 5: | |
7922 #if 0 | |
7923 | slice_group_change_direction_flag |1 |u(1) | | |
7924 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7925 #endif | |
7926 break; | |
7927 case 6: | |
7928 #if 0 | |
7929 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7930 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7931 |) | | | | |
7932 | slice_group_id[ i ] |1 |u(v) | | |
7933 #endif | |
1214 | 7934 break; |
1168 | 7935 } |
7936 } | |
7937 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7938 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
7939 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
|
7940 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
1168 | 7941 return -1; |
7942 } | |
2967 | 7943 |
1168 | 7944 pps->weighted_pred= get_bits1(&s->gb); |
7945 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7946 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7947 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7948 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7949 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7950 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7951 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7952 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7953 pps->transform_8x8_mode= 0; |
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7954 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7955 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7956 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7957 |
7958 if(get_bits_count(&s->gb) < bit_length){ | |
7959 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7960 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7961 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7962 } | |
2967 | 7963 |
1168 | 7964 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 7965 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 | 7966 pps_id, pps->sps_id, |
7967 pps->cabac ? "CABAC" : "CAVLC", | |
7968 pps->slice_group_count, | |
7969 pps->ref_count[0], pps->ref_count[1], | |
7970 pps->weighted_pred ? "weighted" : "", | |
7971 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7972 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7973 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7974 pps->redundant_pic_cnt_present ? "REDU" : "", |
7975 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7976 ); |
7977 } | |
2967 | 7978 |
1168 | 7979 return 0; |
7980 } | |
7981 | |
7982 /** | |
7983 * finds the end of the current frame in the bitstream. | |
7984 * @return the position of the first byte of the next frame, or -1 | |
7985 */ | |
2392 | 7986 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7987 int i; |
1168 | 7988 uint32_t state; |
2392 | 7989 ParseContext *pc = &(h->s.parse_context); |
1168 | 7990 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7991 // mb_addr= pc->mb_addr - 1; | |
7992 state= pc->state; | |
2392 | 7993 for(i=0; i<=buf_size; i++){ |
1168 | 7994 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7995 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7996 if(pc->frame_start_found){ |
2392 | 7997 // If there isn't one more byte in the buffer |
7998 // the test on first_mb_in_slice cannot be done yet | |
7999 // do it at next call. | |
8000 if (i >= buf_size) break; | |
8001 if (buf[i] & 0x80) { | |
8002 // first_mb_in_slice is 0, probably the first nal of a new | |
8003 // slice | |
8004 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 8005 pc->state=-1; |
2392 | 8006 pc->frame_start_found= 0; |
8007 return i-4; | |
8008 } | |
1168 | 8009 } |
2392 | 8010 pc->frame_start_found = 1; |
1168 | 8011 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8012 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
|
8013 if(pc->frame_start_found){ |
2967 | 8014 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8015 pc->frame_start_found= 0; |
2967 | 8016 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8017 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8018 } |
2392 | 8019 if (i<buf_size) |
8020 state= (state<<8) | buf[i]; | |
1168 | 8021 } |
2967 | 8022 |
1168 | 8023 pc->state= state; |
1219 | 8024 return END_NOT_FOUND; |
1168 | 8025 } |
8026 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8027 #ifdef CONFIG_H264_PARSER |
1988 | 8028 static int h264_parse(AVCodecParserContext *s, |
8029 AVCodecContext *avctx, | |
2967 | 8030 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 8031 const uint8_t *buf, int buf_size) |
8032 { | |
2392 | 8033 H264Context *h = s->priv_data; |
8034 ParseContext *pc = &h->s.parse_context; | |
1988 | 8035 int next; |
2967 | 8036 |
2392 | 8037 next= find_frame_end(h, buf, buf_size); |
1988 | 8038 |
8039 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
8040 *poutbuf = NULL; | |
8041 *poutbuf_size = 0; | |
8042 return buf_size; | |
8043 } | |
8044 | |
8045 *poutbuf = (uint8_t *)buf; | |
8046 *poutbuf_size = buf_size; | |
8047 return next; | |
8048 } | |
8049 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8050 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8051 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8052 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8053 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8054 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8055 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8056 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8057 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8058 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8059 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8060 /* 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
|
8061 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8062 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
|
8063 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8064 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
|
8065 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8066 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8067 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8068 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8069 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8070 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8071 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8072 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8073 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8074 |
1168 | 8075 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
8076 MpegEncContext * const s = &h->s; | |
8077 AVCodecContext * const avctx= s->avctx; | |
8078 int buf_index=0; | |
1322 | 8079 #if 0 |
1168 | 8080 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8081 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8082 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 8083 } |
8084 #endif | |
2392 | 8085 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8086 s->current_picture_ptr= NULL; |
1168 | 8087 for(;;){ |
8088 int consumed; | |
8089 int dst_length; | |
8090 int bit_length; | |
8091 uint8_t *ptr; | |
2227 | 8092 int i, nalsize = 0; |
2967 | 8093 |
2227 | 8094 if(h->is_avc) { |
8095 if(buf_index >= buf_size) break; | |
8096 nalsize = 0; | |
8097 for(i = 0; i < h->nal_length_size; i++) | |
8098 nalsize = (nalsize << 8) | buf[buf_index++]; | |
3126 | 8099 if(nalsize <= 1){ |
8100 if(nalsize == 1){ | |
8101 buf_index++; | |
8102 continue; | |
8103 }else{ | |
8104 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8105 break; | |
8106 } | |
8107 } | |
2227 | 8108 } else { |
1168 | 8109 // start code prefix search |
8110 for(; buf_index + 3 < buf_size; buf_index++){ | |
8111 // this should allways succeed in the first iteration | |
8112 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8113 break; | |
8114 } | |
2967 | 8115 |
1168 | 8116 if(buf_index+3 >= buf_size) break; |
2967 | 8117 |
1168 | 8118 buf_index+=3; |
2967 | 8119 } |
8120 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8121 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
3341 | 8122 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8123 dst_length--; | |
1168 | 8124 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8125 | |
8126 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8127 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 | 8128 } |
2967 | 8129 |
2227 | 8130 if (h->is_avc && (nalsize != consumed)) |
8131 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8132 | |
1168 | 8133 buf_index += consumed; |
8134 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8135 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8136 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8137 continue; |
2967 | 8138 |
1168 | 8139 switch(h->nal_unit_type){ |
8140 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8141 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8142 case NAL_SLICE: |
8143 init_get_bits(&s->gb, ptr, bit_length); | |
8144 h->intra_gb_ptr= | |
8145 h->inter_gb_ptr= &s->gb; | |
8146 s->data_partitioning = 0; | |
2967 | 8147 |
2771 | 8148 if(decode_slice_header(h) < 0){ |
8149 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8150 break; | |
8151 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8152 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8153 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8154 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8155 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8156 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8157 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8158 decode_slice(h); |
8159 break; | |
8160 case NAL_DPA: | |
8161 init_get_bits(&s->gb, ptr, bit_length); | |
8162 h->intra_gb_ptr= | |
8163 h->inter_gb_ptr= NULL; | |
8164 s->data_partitioning = 1; | |
2967 | 8165 |
2771 | 8166 if(decode_slice_header(h) < 0){ |
8167 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8168 } | |
1168 | 8169 break; |
8170 case NAL_DPB: | |
8171 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8172 h->intra_gb_ptr= &h->intra_gb; | |
8173 break; | |
8174 case NAL_DPC: | |
8175 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8176 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8177 |
2967 | 8178 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning |
2793 | 8179 && s->hurry_up < 5 |
8180 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8181 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8182 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8183 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8184 decode_slice(h); |
8185 break; | |
8186 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8187 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
|
8188 decode_sei(h); |
1168 | 8189 break; |
8190 case NAL_SPS: | |
8191 init_get_bits(&s->gb, ptr, bit_length); | |
8192 decode_seq_parameter_set(h); | |
2967 | 8193 |
1168 | 8194 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8195 s->low_delay=1; | |
2967 | 8196 |
2538 | 8197 if(avctx->has_b_frames < 2) |
8198 avctx->has_b_frames= !s->low_delay; | |
1168 | 8199 break; |
8200 case NAL_PPS: | |
8201 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8202 |
2755 | 8203 decode_picture_parameter_set(h, bit_length); |
1168 | 8204 |
8205 break; | |
2960 | 8206 case NAL_AUD: |
8207 case NAL_END_SEQUENCE: | |
8208 case NAL_END_STREAM: | |
8209 case NAL_FILLER_DATA: | |
8210 case NAL_SPS_EXT: | |
8211 case NAL_AUXILIARY_SLICE: | |
1168 | 8212 break; |
2979 | 8213 default: |
8214 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8215 } |
8216 } | |
8217 | |
1174 | 8218 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
|
8219 |
2971 | 8220 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
|
8221 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8222 |
1168 | 8223 h->prev_frame_num_offset= h->frame_num_offset; |
8224 h->prev_frame_num= h->frame_num; | |
8225 if(s->current_picture_ptr->reference){ | |
8226 h->prev_poc_msb= h->poc_msb; | |
8227 h->prev_poc_lsb= h->poc_lsb; | |
8228 } | |
8229 if(s->current_picture_ptr->reference) | |
8230 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8231 | |
8232 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
|
8233 |
1168 | 8234 MPV_frame_end(s); |
8235 | |
8236 return buf_index; | |
8237 } | |
8238 | |
8239 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8240 * returns the number of bytes consumed for building the current frame |
1168 | 8241 */ |
8242 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8243 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8244 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8245 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8246 |
1168 | 8247 return pos; |
8248 }else{ | |
8249 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8250 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8251 | |
8252 return pos; | |
8253 } | |
8254 } | |
8255 | |
2967 | 8256 static int decode_frame(AVCodecContext *avctx, |
1168 | 8257 void *data, int *data_size, |
8258 uint8_t *buf, int buf_size) | |
8259 { | |
8260 H264Context *h = avctx->priv_data; | |
8261 MpegEncContext *s = &h->s; | |
2967 | 8262 AVFrame *pict = data; |
1168 | 8263 int buf_index; |
2967 | 8264 |
1168 | 8265 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8266 s->flags2= avctx->flags2; |
1168 | 8267 |
8268 /* no supplementary picture */ | |
8269 if (buf_size == 0) { | |
8270 return 0; | |
8271 } | |
2967 | 8272 |
1168 | 8273 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8274 int next= find_frame_end(h, buf, buf_size); |
2967 | 8275 |
1988 | 8276 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8277 return buf_size; |
8278 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8279 } | |
8280 | |
2227 | 8281 if(h->is_avc && !h->got_avcC) { |
8282 int i, cnt, nalsize; | |
8283 unsigned char *p = avctx->extradata; | |
8284 if(avctx->extradata_size < 7) { | |
8285 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8286 return -1; | |
8287 } | |
8288 if(*p != 1) { | |
8289 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8290 return -1; | |
8291 } | |
8292 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8293 so put a fake nal_length_size = 2 while parsing them */ | |
8294 h->nal_length_size = 2; | |
8295 // Decode sps from avcC | |
8296 cnt = *(p+5) & 0x1f; // Number of sps | |
8297 p += 6; | |
8298 for (i = 0; i < cnt; i++) { | |
8299 nalsize = BE_16(p) + 2; | |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8300 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8301 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8302 return -1; | |
8303 } | |
8304 p += nalsize; | |
2967 | 8305 } |
2227 | 8306 // Decode pps from avcC |
8307 cnt = *(p++); // Number of pps | |
8308 for (i = 0; i < cnt; i++) { | |
8309 nalsize = BE_16(p) + 2; | |
8310 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
8311 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8312 return -1; | |
8313 } | |
8314 p += nalsize; | |
2967 | 8315 } |
2227 | 8316 // Now store right nal length size, that will be use to parse all other nals |
8317 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8318 // Do not reparse avcC | |
8319 h->got_avcC = 1; | |
8320 } | |
8321 | |
8322 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){ | |
2967 | 8323 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8324 return -1; |
8325 } | |
8326 | |
8327 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8328 if(buf_index < 0) |
1168 | 8329 return -1; |
8330 | |
2967 | 8331 //FIXME do something with unavailable reference frames |
8332 | |
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
|
8333 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8334 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8335 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8336 return -1; |
8337 } | |
8338 | |
2409 | 8339 { |
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
|
8340 Picture *out = s->current_picture_ptr; |
2561 | 8341 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8342 *data_size = sizeof(AVFrame); |
2561 | 8343 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8344 /* Sort B-frames into display order */ |
2409 | 8345 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
|
8346 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8347 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
|
8348 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8349 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
|
8350 && 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
|
8351 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
|
8352 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8353 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8354 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8355 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8356 while(h->delayed_pic[pics]) pics++; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8357 h->delayed_pic[pics++] = cur; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8358 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8359 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8360 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8361 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8362 for(i=0; h->delayed_pic[i]; i++) |
2649
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
8363 if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8364 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8365 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8366 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8367 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8368 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8369 if(h->delayed_pic[i]->poc < out->poc){ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8370 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8371 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8372 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8373 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8374 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8375 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8376 { } | |
8377 else if(prev && pics <= s->avctx->has_b_frames) | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8378 out = prev; |
2923 | 8379 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8380 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8381 ((!cross_idr && prev && out->poc > prev->poc + 2) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8382 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8383 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8384 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8385 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8386 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8387 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8388 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8389 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8390 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8391 if(out_of_order || pics > s->avctx->has_b_frames){ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8392 for(i=out_idx; h->delayed_pic[i]; i++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8393 h->delayed_pic[i] = h->delayed_pic[i+1]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8394 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8395 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8396 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8397 *data_size = 0; |
2561 | 8398 else |
8399 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8400 if(prev && prev != out && prev->reference == 1) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8401 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8402 h->delayed_output_pic = out; |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
8403 #endif |
2409 | 8404 |
2937 | 8405 if(out) |
8406 *pict= *(AVFrame*)out; | |
8407 else | |
8408 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8409 } | |
8410 | |
8411 assert(pict->data[0] || !*data_size); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1698
diff
changeset
|
8412 ff_print_debug_info(s, pict); |
1168 | 8413 //printf("out %d\n", (int)pict->data[0]); |
8414 #if 0 //? | |
8415 | |
8416 /* Return the Picture timestamp as the frame number */ | |
8417 /* we substract 1 because it is added on utils.c */ | |
8418 avctx->frame_number = s->picture_number - 1; | |
8419 #endif | |
8420 return get_consumed_bytes(s, buf_index, buf_size); | |
8421 } | |
8422 #if 0 | |
8423 static inline void fill_mb_avail(H264Context *h){ | |
8424 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8425 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8426 |
8427 if(s->mb_y){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8428 h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8429 h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8430 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8431 }else{ |
8432 h->mb_avail[0]= | |
8433 h->mb_avail[1]= | |
8434 h->mb_avail[2]= 0; | |
8435 } | |
8436 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8437 h->mb_avail[4]= 1; //FIXME move out | |
8438 h->mb_avail[5]= 0; //FIXME move out | |
8439 } | |
8440 #endif | |
8441 | |
8442 #if 0 //selftest | |
8443 #define COUNT 8000 | |
8444 #define SIZE (COUNT*40) | |
8445 int main(){ | |
8446 int i; | |
8447 uint8_t temp[SIZE]; | |
8448 PutBitContext pb; | |
8449 GetBitContext gb; | |
8450 // int int_temp[10000]; | |
8451 DSPContext dsp; | |
8452 AVCodecContext avctx; | |
2967 | 8453 |
1168 | 8454 dsputil_init(&dsp, &avctx); |
8455 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8456 init_put_bits(&pb, temp, SIZE); |
1168 | 8457 printf("testing unsigned exp golomb\n"); |
8458 for(i=0; i<COUNT; i++){ | |
8459 START_TIMER | |
8460 set_ue_golomb(&pb, i); | |
8461 STOP_TIMER("set_ue_golomb"); | |
8462 } | |
8463 flush_put_bits(&pb); | |
2967 | 8464 |
1168 | 8465 init_get_bits(&gb, temp, 8*SIZE); |
8466 for(i=0; i<COUNT; i++){ | |
8467 int j, s; | |
2967 | 8468 |
1168 | 8469 s= show_bits(&gb, 24); |
2967 | 8470 |
1168 | 8471 START_TIMER |
8472 j= get_ue_golomb(&gb); | |
8473 if(j != i){ | |
8474 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8475 // return -1; | |
8476 } | |
8477 STOP_TIMER("get_ue_golomb"); | |
8478 } | |
2967 | 8479 |
8480 | |
1524 | 8481 init_put_bits(&pb, temp, SIZE); |
1168 | 8482 printf("testing signed exp golomb\n"); |
8483 for(i=0; i<COUNT; i++){ | |
8484 START_TIMER | |
8485 set_se_golomb(&pb, i - COUNT/2); | |
8486 STOP_TIMER("set_se_golomb"); | |
8487 } | |
8488 flush_put_bits(&pb); | |
2967 | 8489 |
1168 | 8490 init_get_bits(&gb, temp, 8*SIZE); |
8491 for(i=0; i<COUNT; i++){ | |
8492 int j, s; | |
2967 | 8493 |
1168 | 8494 s= show_bits(&gb, 24); |
2967 | 8495 |
1168 | 8496 START_TIMER |
8497 j= get_se_golomb(&gb); | |
8498 if(j != i - COUNT/2){ | |
8499 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8500 // return -1; | |
8501 } | |
8502 STOP_TIMER("get_se_golomb"); | |
8503 } | |
8504 | |
8505 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8506 |
1168 | 8507 DCTELEM block[16]; |
8508 uint8_t src[16], ref[16]; | |
8509 uint64_t error= 0, max_error=0; | |
8510 | |
8511 for(i=0; i<COUNT; i++){ | |
8512 int j; | |
8513 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8514 for(j=0; j<16; j++){ | |
8515 ref[j]= random()%255; | |
8516 src[j]= random()%255; | |
8517 } | |
8518 | |
8519 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8520 |
1168 | 8521 //normalize |
8522 for(j=0; j<16; j++){ | |
8523 // printf("%d ", block[j]); | |
8524 block[j]= block[j]*4; | |
8525 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8526 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8527 } | |
8528 // printf("\n"); | |
2967 | 8529 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8530 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8531 /* for(j=0; j<16; j++){ |
8532 printf("%d ", ref[j]); | |
8533 } | |
8534 printf("\n");*/ | |
2967 | 8535 |
1168 | 8536 for(j=0; j<16; j++){ |
4001 | 8537 int diff= FFABS(src[j] - ref[j]); |
2967 | 8538 |
1168 | 8539 error+= diff*diff; |
8540 max_error= FFMAX(max_error, diff); | |
8541 } | |
8542 } | |
8543 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8544 #if 0 | |
8545 printf("testing quantizer\n"); | |
8546 for(qp=0; qp<52; qp++){ | |
8547 for(i=0; i<16; i++) | |
8548 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8549 |
1168 | 8550 } |
8551 #endif | |
8552 printf("Testing NAL layer\n"); | |
2967 | 8553 |
1168 | 8554 uint8_t bitstream[COUNT]; |
8555 uint8_t nal[COUNT*2]; | |
8556 H264Context h; | |
8557 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8558 |
1168 | 8559 for(i=0; i<COUNT; i++){ |
8560 int zeros= i; | |
8561 int nal_length; | |
8562 int consumed; | |
8563 int out_length; | |
8564 uint8_t *out; | |
8565 int j; | |
2967 | 8566 |
1168 | 8567 for(j=0; j<COUNT; j++){ |
8568 bitstream[j]= (random() % 255) + 1; | |
8569 } | |
2967 | 8570 |
1168 | 8571 for(j=0; j<zeros; j++){ |
8572 int pos= random() % COUNT; | |
8573 while(bitstream[pos] == 0){ | |
8574 pos++; | |
8575 pos %= COUNT; | |
8576 } | |
8577 bitstream[pos]=0; | |
8578 } | |
2967 | 8579 |
1168 | 8580 START_TIMER |
2967 | 8581 |
1168 | 8582 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8583 if(nal_length<0){ | |
8584 printf("encoding failed\n"); | |
8585 return -1; | |
8586 } | |
2967 | 8587 |
1168 | 8588 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8589 | |
8590 STOP_TIMER("NAL") | |
2967 | 8591 |
1168 | 8592 if(out_length != COUNT){ |
8593 printf("incorrect length %d %d\n", out_length, COUNT); | |
8594 return -1; | |
8595 } | |
2967 | 8596 |
1168 | 8597 if(consumed != nal_length){ |
8598 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8599 return -1; | |
8600 } | |
2967 | 8601 |
1168 | 8602 if(memcmp(bitstream, out, COUNT)){ |
8603 printf("missmatch\n"); | |
8604 return -1; | |
8605 } | |
8606 } | |
2967 | 8607 |
1168 | 8608 printf("Testing RBSP\n"); |
2967 | 8609 |
8610 | |
1168 | 8611 return 0; |
8612 } | |
8613 #endif | |
8614 | |
8615 | |
8616 static int decode_end(AVCodecContext *avctx) | |
8617 { | |
8618 H264Context *h = avctx->priv_data; | |
8619 MpegEncContext *s = &h->s; | |
2967 | 8620 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8621 av_freep(&h->rbsp_buffer); |
1168 | 8622 free_tables(h); //FIXME cleanup init stuff perhaps |
8623 MPV_common_end(s); | |
8624 | |
8625 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8626 |
1168 | 8627 return 0; |
8628 } | |
8629 | |
8630 | |
8631 AVCodec h264_decoder = { | |
8632 "h264", | |
8633 CODEC_TYPE_VIDEO, | |
8634 CODEC_ID_H264, | |
8635 sizeof(H264Context), | |
8636 decode_init, | |
8637 NULL, | |
8638 decode_end, | |
8639 decode_frame, | |
2453 | 8640 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8641 .flush= flush_dpb, |
1168 | 8642 }; |
8643 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8644 #ifdef CONFIG_H264_PARSER |
1988 | 8645 AVCodecParser h264_parser = { |
8646 { CODEC_ID_H264 }, | |
2392 | 8647 sizeof(H264Context), |
1988 | 8648 NULL, |
8649 h264_parse, | |
8650 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8651 h264_split, |
1988 | 8652 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8653 #endif |
1988 | 8654 |
1234 | 8655 #include "svq3.c" |