Mercurial > libavcodec.hg
annotate h264.c @ 4520:9bf957e669f0 libavcodec
This fixes error handling for BeOS, removing the need for some ifdefs.
AVERROR_ defines are moved to avcodec.h as they are needed in there as well. Feel free to move that to avutil/common.h.
Bumped up avcodec/format version numbers as though it's binary compatible we will want to rebuild apps as error values changed.
Please from now on use return AVERROR(EFOO) instead of the ugly return -EFOO in your code.
This also removes the need for berrno.h.
author | mmu_man |
---|---|
date | Tue, 13 Feb 2007 18:26:14 +0000 |
parents | b80c704183e9 |
children | a8082e1ed672 |
rev | line source |
---|---|
1168 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1168 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1168 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1168 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3029
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1168 | 20 * |
21 */ | |
2967 | 22 |
1168 | 23 /** |
24 * @file h264.c | |
25 * H.264 / AVC / MPEG4 part10 codec. | |
26 * @author Michael Niedermayer <michaelni@gmx.at> | |
27 */ | |
28 | |
29 #include "common.h" | |
30 #include "dsputil.h" | |
31 #include "avcodec.h" | |
32 #include "mpegvideo.h" | |
33 #include "h264data.h" | |
34 #include "golomb.h" | |
35 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
36 #include "cabac.h" |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
37 |
3284
a224d9752912
don't force asserts in release builds. 2% faster h264.
lorenm
parents:
3219
diff
changeset
|
38 //#undef NDEBUG |
1168 | 39 #include <assert.h> |
40 | |
41 #define interlaced_dct interlaced_dct_is_a_bad_name | |
42 #define mb_intra mb_intra_isnt_initalized_see_mb_type | |
43 | |
44 #define LUMA_DC_BLOCK_INDEX 25 | |
45 #define CHROMA_DC_BLOCK_INDEX 26 | |
46 | |
47 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
48 #define COEFF_TOKEN_VLC_BITS 8 | |
49 #define TOTAL_ZEROS_VLC_BITS 9 | |
50 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
51 #define RUN_VLC_BITS 3 | |
52 #define RUN7_VLC_BITS 6 | |
53 | |
54 #define MAX_SPS_COUNT 32 | |
55 #define MAX_PPS_COUNT 256 | |
56 | |
57 #define MAX_MMCO_COUNT 66 | |
58 | |
3316 | 59 /* Compiling in interlaced support reduces the speed |
60 * of progressive decoding by about 2%. */ | |
61 #define ALLOW_INTERLACE | |
62 | |
63 #ifdef ALLOW_INTERLACE | |
64 #define MB_MBAFF h->mb_mbaff | |
65 #define MB_FIELD h->mb_field_decoding_flag | |
66 #define FRAME_MBAFF h->mb_aff_frame | |
67 #else | |
68 #define MB_MBAFF 0 | |
69 #define MB_FIELD 0 | |
70 #define FRAME_MBAFF 0 | |
71 #undef IS_INTERLACED | |
72 #define IS_INTERLACED(mb_type) 0 | |
73 #endif | |
74 | |
1168 | 75 /** |
76 * Sequence parameter set | |
77 */ | |
78 typedef struct SPS{ | |
2967 | 79 |
1168 | 80 int profile_idc; |
81 int level_idc; | |
2763 | 82 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag |
1168 | 83 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 |
84 int poc_type; ///< pic_order_cnt_type | |
85 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
86 int delta_pic_order_always_zero_flag; | |
87 int offset_for_non_ref_pic; | |
88 int offset_for_top_to_bottom_field; | |
89 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
90 int ref_frame_count; ///< num_ref_frames | |
1371 | 91 int gaps_in_frame_num_allowed_flag; |
1168 | 92 int mb_width; ///< frame_width_in_mbs_minus1 + 1 |
93 int mb_height; ///< frame_height_in_mbs_minus1 + 1 | |
94 int frame_mbs_only_flag; | |
95 int mb_aff; ///<mb_adaptive_frame_field_flag | |
96 int direct_8x8_inference_flag; | |
1371 | 97 int crop; ///< frame_cropping_flag |
98 int crop_left; ///< frame_cropping_rect_left_offset | |
99 int crop_right; ///< frame_cropping_rect_right_offset | |
100 int crop_top; ///< frame_cropping_rect_top_offset | |
101 int crop_bottom; ///< frame_cropping_rect_bottom_offset | |
1168 | 102 int vui_parameters_present_flag; |
1548 | 103 AVRational sar; |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
104 int timing_info_present_flag; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
105 uint32_t num_units_in_tick; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
106 uint32_t time_scale; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
107 int fixed_frame_rate_flag; |
1168 | 108 short offset_for_ref_frame[256]; //FIXME dyn aloc? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
109 int bitstream_restriction_flag; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
110 int num_reorder_frames; |
2919 | 111 int scaling_matrix_present; |
112 uint8_t scaling_matrix4[6][16]; | |
113 uint8_t scaling_matrix8[2][64]; | |
1168 | 114 }SPS; |
115 | |
116 /** | |
117 * Picture parameter set | |
118 */ | |
119 typedef struct PPS{ | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
120 unsigned int sps_id; |
1168 | 121 int cabac; ///< entropy_coding_mode_flag |
122 int pic_order_present; ///< pic_order_present_flag | |
123 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
124 int mb_slice_group_map_type; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
125 unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 |
1168 | 126 int weighted_pred; ///< weighted_pred_flag |
127 int weighted_bipred_idc; | |
128 int init_qp; ///< pic_init_qp_minus26 + 26 | |
129 int init_qs; ///< pic_init_qs_minus26 + 26 | |
130 int chroma_qp_index_offset; | |
131 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag | |
132 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
133 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
2755 | 134 int transform_8x8_mode; ///< transform_8x8_mode_flag |
2919 | 135 uint8_t scaling_matrix4[6][16]; |
136 uint8_t scaling_matrix8[2][64]; | |
1168 | 137 }PPS; |
138 | |
139 /** | |
140 * Memory management control operation opcode. | |
141 */ | |
142 typedef enum MMCOOpcode{ | |
143 MMCO_END=0, | |
144 MMCO_SHORT2UNUSED, | |
145 MMCO_LONG2UNUSED, | |
146 MMCO_SHORT2LONG, | |
147 MMCO_SET_MAX_LONG, | |
2967 | 148 MMCO_RESET, |
1168 | 149 MMCO_LONG, |
150 } MMCOOpcode; | |
151 | |
152 /** | |
153 * Memory management control operation. | |
154 */ | |
155 typedef struct MMCO{ | |
156 MMCOOpcode opcode; | |
157 int short_frame_num; | |
158 int long_index; | |
159 } MMCO; | |
160 | |
161 /** | |
162 * H264Context | |
163 */ | |
164 typedef struct H264Context{ | |
165 MpegEncContext s; | |
2967 | 166 int nal_ref_idc; |
1168 | 167 int nal_unit_type; |
168 uint8_t *rbsp_buffer; | |
3066
04b924f8f5a5
warning fixes by Luca Abeni, lucabe72 ##@## email ##.## it
diego
parents:
3063
diff
changeset
|
169 unsigned int rbsp_buffer_size; |
1168 | 170 |
2227 | 171 /** |
172 * Used to parse AVC variant of h264 | |
173 */ | |
174 int is_avc; ///< this flag is != 0 if codec is avc1 | |
175 int got_avcC; ///< flag used to parse avcC data only once | |
176 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
177 | |
1168 | 178 int chroma_qp; //QPc |
179 | |
3316 | 180 int prev_mb_skipped; |
181 int next_mb_skipped; | |
1168 | 182 |
183 //prediction stuff | |
184 int chroma_pred_mode; | |
185 int intra16x16_pred_mode; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
186 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
187 int top_mb_xy; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
188 int left_mb_xy[2]; |
2967 | 189 |
1168 | 190 int8_t intra4x4_pred_mode_cache[5*8]; |
191 int8_t (*intra4x4_pred_mode)[8]; | |
192 void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp? | |
2755 | 193 void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride); |
1168 | 194 void (*pred8x8 [4+3])(uint8_t *src, int stride); |
195 void (*pred16x16[4+3])(uint8_t *src, int stride); | |
196 unsigned int topleft_samples_available; | |
197 unsigned int top_samples_available; | |
198 unsigned int topright_samples_available; | |
199 unsigned int left_samples_available; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
200 uint8_t (*top_borders[2])[16+2*8]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
201 uint8_t left_border[2*(17+2*9)]; |
1168 | 202 |
203 /** | |
204 * non zero coeff count cache. | |
205 * is 64 if not available. | |
206 */ | |
3089 | 207 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
208 uint8_t (*non_zero_count)[16]; |
1168 | 209 |
210 /** | |
211 * Motion vector cache. | |
212 */ | |
3089 | 213 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); |
214 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); | |
1168 | 215 #define LIST_NOT_USED -1 //FIXME rename? |
216 #define PART_NOT_AVAILABLE -2 | |
2967 | 217 |
1168 | 218 /** |
219 * is 1 if the specific list MV&references are set to 0,0,-2. | |
220 */ | |
221 int mv_cache_clean[2]; | |
222 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
223 /** |
2755 | 224 * number of neighbors (top and/or left) that used 8x8 dct |
225 */ | |
226 int neighbor_transform_size; | |
227 | |
228 /** | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
229 * block_offset[ 0..23] for frame macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
230 * block_offset[24..47] for field macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
231 */ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
232 int block_offset[2*(16+8)]; |
2967 | 233 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
234 uint32_t *mb2b_xy; //FIXME are these 4 a good idea? |
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
235 uint32_t *mb2b8_xy; |
2395 | 236 int b_stride; //FIXME use s->b4_stride |
1168 | 237 int b8_stride; |
238 | |
3316 | 239 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff |
240 int mb_uvlinesize; | |
241 | |
242 int emu_edge_width; | |
243 int emu_edge_height; | |
244 | |
1234 | 245 int halfpel_flag; |
246 int thirdpel_flag; | |
247 | |
1319 | 248 int unknown_svq3_flag; |
249 int next_slice_index; | |
250 | |
1168 | 251 SPS sps_buffer[MAX_SPS_COUNT]; |
252 SPS sps; ///< current sps | |
2967 | 253 |
1168 | 254 PPS pps_buffer[MAX_PPS_COUNT]; |
255 /** | |
256 * current pps | |
257 */ | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
258 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? |
1168 | 259 |
2919 | 260 uint32_t dequant4_buffer[6][52][16]; |
261 uint32_t dequant8_buffer[2][52][64]; | |
262 uint32_t (*dequant4_coeff[6])[16]; | |
263 uint32_t (*dequant8_coeff[2])[64]; | |
264 int dequant_coeff_pps; ///< reinit tables when pps changes | |
2755 | 265 |
1168 | 266 int slice_num; |
267 uint8_t *slice_table_base; | |
3316 | 268 uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
1168 | 269 int slice_type; |
270 int slice_type_fixed; | |
2967 | 271 |
1168 | 272 //interlacing specific flags |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
273 int mb_aff_frame; |
1168 | 274 int mb_field_decoding_flag; |
3316 | 275 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag |
2967 | 276 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
277 unsigned int sub_mb_type[4]; |
2967 | 278 |
1168 | 279 //POC stuff |
280 int poc_lsb; | |
281 int poc_msb; | |
282 int delta_poc_bottom; | |
283 int delta_poc[2]; | |
284 int frame_num; | |
285 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
286 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
287 int frame_num_offset; ///< for POC type 2 | |
288 int prev_frame_num_offset; ///< for POC type 2 | |
289 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
290 | |
291 /** | |
292 * frame_num for frames or 2*frame_num for field pics. | |
293 */ | |
294 int curr_pic_num; | |
2967 | 295 |
1168 | 296 /** |
297 * max_frame_num or 2*max_frame_num for field pics. | |
298 */ | |
299 int max_pic_num; | |
300 | |
301 //Weighted pred stuff | |
2415 | 302 int use_weight; |
303 int use_weight_chroma; | |
1168 | 304 int luma_log2_weight_denom; |
305 int chroma_log2_weight_denom; | |
3316 | 306 int luma_weight[2][48]; |
307 int luma_offset[2][48]; | |
308 int chroma_weight[2][48][2]; | |
309 int chroma_offset[2][48][2]; | |
310 int implicit_weight[48][48]; | |
2967 | 311 |
1168 | 312 //deblock |
2967 | 313 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
314 int slice_alpha_c0_offset; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
315 int slice_beta_offset; |
2967 | 316 |
1168 | 317 int redundant_pic_count; |
2967 | 318 |
1168 | 319 int direct_spatial_mv_pred; |
2396 | 320 int dist_scale_factor[16]; |
3316 | 321 int dist_scale_factor_field[32]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
322 int map_col_to_list0[2][16]; |
3316 | 323 int map_col_to_list0_field[2][32]; |
1168 | 324 |
325 /** | |
326 * num_ref_idx_l0/1_active_minus1 + 1 | |
327 */ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
328 unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
2582 | 329 Picture *short_ref[32]; |
330 Picture *long_ref[32]; | |
1168 | 331 Picture default_ref_list[2][32]; |
3316 | 332 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs |
4389 | 333 Picture *delayed_pic[18]; //FIXME size? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
334 Picture *delayed_output_pic; |
2967 | 335 |
1168 | 336 /** |
337 * memory management control operations buffer. | |
338 */ | |
339 MMCO mmco[MAX_MMCO_COUNT]; | |
340 int mmco_index; | |
2967 | 341 |
1168 | 342 int long_ref_count; ///< number of actual long term references |
343 int short_ref_count; ///< number of actual short term references | |
2967 | 344 |
1168 | 345 //data partitioning |
346 GetBitContext intra_gb; | |
347 GetBitContext inter_gb; | |
348 GetBitContext *intra_gb_ptr; | |
349 GetBitContext *inter_gb_ptr; | |
2967 | 350 |
3089 | 351 DECLARE_ALIGNED_8(DCTELEM, mb[16*24]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
352 DCTELEM mb_padding[256]; ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not to large or ensure that there is some unused stuff after mb |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
353 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
354 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
355 * Cabac |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
356 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
357 CABACContext cabac; |
2755 | 358 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
|
359 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
|
360 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
361 /* 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
|
362 uint16_t *cbp_table; |
3651 | 363 int cbp; |
2314 | 364 int top_cbp; |
365 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
|
366 /* 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
|
367 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
|
368 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
|
369 int16_t (*mvd_table[2])[2]; |
3089 | 370 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); |
2396 | 371 uint8_t *direct_table; |
372 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
|
373 |
2748
135aa7d0bd17
avoid one transpose (730->680 dezicycles on duron)
michael
parents:
2717
diff
changeset
|
374 uint8_t zigzag_scan[16]; |
3174 | 375 uint8_t zigzag_scan8x8[64]; |
376 uint8_t zigzag_scan8x8_cavlc[64]; | |
3316 | 377 uint8_t field_scan[16]; |
378 uint8_t field_scan8x8[64]; | |
379 uint8_t field_scan8x8_cavlc[64]; | |
2763 | 380 const uint8_t *zigzag_scan_q0; |
3174 | 381 const uint8_t *zigzag_scan8x8_q0; |
382 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
3316 | 383 const uint8_t *field_scan_q0; |
384 const uint8_t *field_scan8x8_q0; | |
385 const uint8_t *field_scan8x8_cavlc_q0; | |
2967 | 386 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
387 int x264_build; |
1168 | 388 }H264Context; |
389 | |
390 static VLC coeff_token_vlc[4]; | |
391 static VLC chroma_dc_coeff_token_vlc; | |
392 | |
393 static VLC total_zeros_vlc[15]; | |
394 static VLC chroma_dc_total_zeros_vlc[3]; | |
395 | |
396 static VLC run_vlc[6]; | |
397 static VLC run7_vlc; | |
398 | |
1234 | 399 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
400 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
|
401 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
|
402 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 | 403 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
404 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 405 #ifdef WORDS_BIGENDIAN |
406 return (b&0xFFFF) + (a<<16); | |
407 #else | |
408 return (a&0xFFFF) + (b<<16); | |
409 #endif | |
410 } | |
411 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
412 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
413 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
414 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
415 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
416 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
417 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
418 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
419 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
420 |
1168 | 421 /** |
422 * fill a rectangle. | |
2392 | 423 * @param h height of the rectangle, should be a constant |
424 * @param w width of the rectangle, should be a constant | |
1168 | 425 * @param size the size of val (1 or 4), should be a constant |
426 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
427 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 428 uint8_t *p= (uint8_t*)vp; |
1168 | 429 assert(size==1 || size==4); |
3315 | 430 assert(w<=4); |
2967 | 431 |
1168 | 432 w *= size; |
433 stride *= size; | |
2967 | 434 |
2962 | 435 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 436 assert((stride&(w-1))==0); |
3315 | 437 if(w==2){ |
438 const uint16_t v= size==4 ? val : val*0x0101; | |
439 *(uint16_t*)(p + 0*stride)= v; | |
440 if(h==1) return; | |
441 *(uint16_t*)(p + 1*stride)= v; | |
442 if(h==2) return; | |
1168 | 443 *(uint16_t*)(p + 2*stride)= |
3315 | 444 *(uint16_t*)(p + 3*stride)= v; |
445 }else if(w==4){ | |
446 const uint32_t v= size==4 ? val : val*0x01010101; | |
447 *(uint32_t*)(p + 0*stride)= v; | |
448 if(h==1) return; | |
449 *(uint32_t*)(p + 1*stride)= v; | |
450 if(h==2) return; | |
1168 | 451 *(uint32_t*)(p + 2*stride)= |
3315 | 452 *(uint32_t*)(p + 3*stride)= v; |
453 }else if(w==8){ | |
454 //gcc can't optimize 64bit math on x86_32 | |
455 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
456 const uint64_t v= val*0x0100000001ULL; | |
457 *(uint64_t*)(p + 0*stride)= v; | |
458 if(h==1) return; | |
459 *(uint64_t*)(p + 1*stride)= v; | |
460 if(h==2) return; | |
1168 | 461 *(uint64_t*)(p + 2*stride)= |
3315 | 462 *(uint64_t*)(p + 3*stride)= v; |
463 }else if(w==16){ | |
464 const uint64_t v= val*0x0100000001ULL; | |
1168 | 465 *(uint64_t*)(p + 0+0*stride)= |
466 *(uint64_t*)(p + 8+0*stride)= | |
467 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 468 *(uint64_t*)(p + 8+1*stride)= v; |
469 if(h==2) return; | |
1168 | 470 *(uint64_t*)(p + 0+2*stride)= |
471 *(uint64_t*)(p + 8+2*stride)= | |
472 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 473 *(uint64_t*)(p + 8+3*stride)= v; |
474 #else | |
475 *(uint32_t*)(p + 0+0*stride)= | |
476 *(uint32_t*)(p + 4+0*stride)= val; | |
477 if(h==1) return; | |
478 *(uint32_t*)(p + 0+1*stride)= | |
479 *(uint32_t*)(p + 4+1*stride)= val; | |
480 if(h==2) return; | |
481 *(uint32_t*)(p + 0+2*stride)= | |
482 *(uint32_t*)(p + 4+2*stride)= | |
483 *(uint32_t*)(p + 0+3*stride)= | |
484 *(uint32_t*)(p + 4+3*stride)= val; | |
485 }else if(w==16){ | |
486 *(uint32_t*)(p + 0+0*stride)= | |
487 *(uint32_t*)(p + 4+0*stride)= | |
488 *(uint32_t*)(p + 8+0*stride)= | |
489 *(uint32_t*)(p +12+0*stride)= | |
490 *(uint32_t*)(p + 0+1*stride)= | |
491 *(uint32_t*)(p + 4+1*stride)= | |
492 *(uint32_t*)(p + 8+1*stride)= | |
493 *(uint32_t*)(p +12+1*stride)= val; | |
494 if(h==2) return; | |
495 *(uint32_t*)(p + 0+2*stride)= | |
496 *(uint32_t*)(p + 4+2*stride)= | |
497 *(uint32_t*)(p + 8+2*stride)= | |
498 *(uint32_t*)(p +12+2*stride)= | |
499 *(uint32_t*)(p + 0+3*stride)= | |
500 *(uint32_t*)(p + 4+3*stride)= | |
501 *(uint32_t*)(p + 8+3*stride)= | |
502 *(uint32_t*)(p +12+3*stride)= val; | |
503 #endif | |
1168 | 504 }else |
505 assert(0); | |
3315 | 506 assert(h==4); |
1168 | 507 } |
508 | |
3028 | 509 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 510 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
|
511 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 512 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
513 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
|
514 int left_block[8]; |
1168 | 515 int i; |
516 | |
3482 | 517 //FIXME deblocking could skip the intra and nnz parts. |
518 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
|
519 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
520 |
2967 | 521 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
522 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
523 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
|
524 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
525 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
526 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
|
527 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
528 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
529 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
530 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
531 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
532 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
533 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
534 left_block[7]= 11; |
3316 | 535 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
536 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
|
537 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
|
538 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
|
539 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
|
540 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
|
541 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
|
542 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
|
543 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
|
544 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
|
545 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
|
546 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
|
547 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
548 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
549 : (!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
|
550 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
551 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
552 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
553 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
554 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
555 : (!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
|
556 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
557 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
558 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
559 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
560 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
561 : (!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
|
562 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
563 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
564 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
565 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
|
566 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
|
567 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
568 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
569 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
570 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
571 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
572 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
573 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
574 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
575 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
576 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
577 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
578 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
579 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
580 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
581 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
582 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
583 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
584 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
585 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
586 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
587 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
588 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
589 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
590 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
591 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
592 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
593 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
594 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
595 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
596 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
597 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
598 } |
1168 | 599 } |
600 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
601 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
|
602 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
|
603 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
|
604 if(for_deblock){ |
3482 | 605 topleft_type = 0; |
606 topright_type = 0; | |
2449 | 607 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
608 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
609 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 610 |
611 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
612 int list; | |
613 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
614 for(i=0; i<16; i++) | |
615 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
616 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ | |
617 if(USES_LIST(mb_type,list)){ | |
618 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
619 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 620 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 621 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
622 dst[0] = src[0]; | |
623 dst[1] = src[1]; | |
624 dst[2] = src[2]; | |
625 dst[3] = src[3]; | |
626 } | |
627 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
628 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
629 ref += h->b8_stride; | |
630 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
631 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
632 }else{ | |
633 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
634 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
635 } | |
636 } | |
637 } | |
2449 | 638 }else{ |
639 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
640 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
641 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
642 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
643 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
644 } | |
1168 | 645 |
646 if(IS_INTRA(mb_type)){ | |
2967 | 647 h->topleft_samples_available= |
648 h->top_samples_available= | |
1168 | 649 h->left_samples_available= 0xFFFF; |
650 h->topright_samples_available= 0xEEEA; | |
651 | |
652 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
653 h->topleft_samples_available= 0xB3FF; | |
654 h->top_samples_available= 0x33FF; | |
655 h->topright_samples_available= 0x26EA; | |
656 } | |
657 for(i=0; i<2; i++){ | |
658 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
659 h->topleft_samples_available&= 0xDF5F; | |
660 h->left_samples_available&= 0x5F5F; | |
661 } | |
662 } | |
2967 | 663 |
1168 | 664 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
665 h->topleft_samples_available&= 0x7FFF; | |
2967 | 666 |
1168 | 667 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
668 h->topright_samples_available&= 0xFBFF; | |
2967 | 669 |
1168 | 670 if(IS_INTRA4x4(mb_type)){ |
671 if(IS_INTRA4x4(top_type)){ | |
672 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
673 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
674 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
675 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
676 }else{ | |
677 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
678 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
|
679 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
680 else{ |
1168 | 681 pred= 2; |
682 } | |
683 h->intra4x4_pred_mode_cache[4+8*0]= | |
684 h->intra4x4_pred_mode_cache[5+8*0]= | |
685 h->intra4x4_pred_mode_cache[6+8*0]= | |
686 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
687 } | |
688 for(i=0; i<2; i++){ | |
689 if(IS_INTRA4x4(left_type[i])){ | |
690 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
691 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
692 }else{ | |
693 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
694 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
|
695 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
696 else{ |
1168 | 697 pred= 2; |
698 } | |
699 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
700 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
701 } | |
702 } | |
703 } | |
704 } | |
2967 | 705 |
706 | |
1168 | 707 /* |
2967 | 708 0 . T T. T T T T |
709 1 L . .L . . . . | |
710 2 L . .L . . . . | |
711 3 . T TL . . . . | |
712 4 L . .L . . . . | |
713 5 L . .. . . . . | |
1168 | 714 */ |
715 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
716 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
717 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
|
718 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
|
719 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
|
720 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 721 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
722 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
|
723 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 724 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
725 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
|
726 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 727 |
1168 | 728 }else{ |
2967 | 729 h->non_zero_count_cache[4+8*0]= |
1168 | 730 h->non_zero_count_cache[5+8*0]= |
731 h->non_zero_count_cache[6+8*0]= | |
732 h->non_zero_count_cache[7+8*0]= | |
2967 | 733 |
1168 | 734 h->non_zero_count_cache[1+8*0]= |
735 h->non_zero_count_cache[2+8*0]= | |
2967 | 736 |
1168 | 737 h->non_zero_count_cache[1+8*3]= |
2314 | 738 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 739 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
740 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
741 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
742 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
743 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
744 h->non_zero_count_cache[3+8*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
|
745 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
|
746 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
|
747 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
|
748 }else{ |
2967 | 749 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
750 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
751 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
|
752 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
|
753 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
754 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
755 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
756 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
|
757 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
758 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
759 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
|
760 } 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
|
761 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
|
762 } else { |
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 = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
764 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
765 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
766 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
|
767 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
|
768 } 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
|
769 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
|
770 } else { |
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 = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
772 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
773 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
|
774 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
|
775 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
776 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
|
777 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
|
778 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
779 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
780 |
1168 | 781 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
782 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 783 int list; |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
784 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
|
785 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 786 /*if(!h->mv_cache_clean[list]){ |
787 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
788 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
789 h->mv_cache_clean[list]= 1; | |
790 }*/ | |
2396 | 791 continue; |
1168 | 792 } |
793 h->mv_cache_clean[list]= 0; | |
2967 | 794 |
3212 | 795 if(USES_LIST(top_type, list)){ |
1168 | 796 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
797 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
798 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
799 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
800 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
801 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
802 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
803 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
804 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
805 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
806 }else{ | |
2967 | 807 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
808 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
809 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 810 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
811 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
812 } | |
813 | |
814 //FIXME unify cleanup or sth | |
3212 | 815 if(USES_LIST(left_type[0], list)){ |
1168 | 816 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
817 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1; | |
818 *(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]]; | |
819 *(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 | 820 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)]; |
821 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 | 822 }else{ |
823 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]= | |
824 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0; | |
825 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
826 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
827 } | |
2967 | 828 |
3212 | 829 if(USES_LIST(left_type[1], list)){ |
1168 | 830 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
831 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1; | |
832 *(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]]; | |
833 *(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 | 834 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)]; |
835 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 | 836 }else{ |
837 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]= | |
838 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0; | |
839 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
840 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
2669 | 841 assert((!left_type[0]) == (!left_type[1])); |
1168 | 842 } |
843 | |
3519 | 844 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 845 continue; |
846 | |
3212 | 847 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
|
848 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
|
849 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
|
850 *(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
|
851 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
|
852 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
853 *(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
|
854 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
|
855 } |
2967 | 856 |
3212 | 857 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
|
858 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
|
859 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
|
860 *(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
|
861 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
|
862 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
863 *(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
|
864 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
|
865 } |
2967 | 866 |
3519 | 867 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 868 continue; |
2967 | 869 |
870 h->ref_cache[list][scan8[5 ]+1] = | |
871 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
872 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 873 h->ref_cache[list][scan8[4 ]] = |
1168 | 874 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
875 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
876 *(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
|
877 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 878 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
879 *(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
|
880 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
881 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
|
882 /* XXX beurk, Load mvd */ |
3212 | 883 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
|
884 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
|
885 *(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
|
886 *(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
|
887 *(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
|
888 *(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
|
889 }else{ |
2967 | 890 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
891 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
892 *(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
|
893 *(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
|
894 } |
3212 | 895 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
|
896 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
|
897 *(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
|
898 *(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
|
899 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
900 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]= |
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 + 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
|
902 } |
3212 | 903 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
|
904 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
|
905 *(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
|
906 *(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
|
907 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
908 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]= |
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 + 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
|
910 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
911 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]= |
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[7 ]+1]= |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
913 *(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
|
914 *(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
|
915 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 916 |
917 if(h->slice_type == B_TYPE){ | |
918 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
919 | |
920 if(IS_DIRECT(top_type)){ | |
921 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
922 }else if(IS_8X8(top_type)){ | |
923 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
924 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
925 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
926 }else{ | |
927 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
928 } | |
2967 | 929 |
3316 | 930 if(IS_DIRECT(left_type[0])) |
931 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
932 else if(IS_8X8(left_type[0])) | |
933 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)]; | |
934 else | |
935 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
936 | |
937 if(IS_DIRECT(left_type[1])) | |
2396 | 938 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 939 else if(IS_8X8(left_type[1])) |
940 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)]; | |
941 else | |
2396 | 942 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 943 } |
944 } | |
945 | |
946 if(FRAME_MBAFF){ | |
947 #define MAP_MVS\ | |
948 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
949 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
950 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
951 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
952 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
953 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
954 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
955 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
956 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
957 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
958 if(MB_FIELD){ | |
959 #define MAP_F2F(idx, mb_type)\ | |
960 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
961 h->ref_cache[list][idx] <<= 1;\ | |
962 h->mv_cache[list][idx][1] /= 2;\ | |
963 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 964 } |
3316 | 965 MAP_MVS |
966 #undef MAP_F2F | |
967 }else{ | |
968 #define MAP_F2F(idx, mb_type)\ | |
969 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
970 h->ref_cache[list][idx] >>= 1;\ | |
971 h->mv_cache[list][idx][1] <<= 1;\ | |
972 h->mvd_cache[list][idx][1] <<= 1;\ | |
973 } | |
974 MAP_MVS | |
975 #undef MAP_F2F | |
2396 | 976 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
977 } |
1168 | 978 } |
979 } | |
980 #endif | |
2755 | 981 |
982 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 983 } |
984 | |
985 static inline void write_back_intra_pred_mode(H264Context *h){ | |
986 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
|
987 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 988 |
989 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
990 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
991 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
992 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
993 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
994 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
995 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
996 } | |
997 | |
998 /** | |
999 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1000 */ | |
1001 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
1002 MpegEncContext * const s = &h->s; | |
1003 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
1004 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
1005 int i; | |
2967 | 1006 |
1168 | 1007 if(!(h->top_samples_available&0x8000)){ |
1008 for(i=0; i<4; i++){ | |
1009 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
1010 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1011 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 1012 return -1; |
1013 } else if(status){ | |
1014 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
1015 } | |
1016 } | |
1017 } | |
2967 | 1018 |
1168 | 1019 if(!(h->left_samples_available&0x8000)){ |
1020 for(i=0; i<4; i++){ | |
1021 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
1022 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1023 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 | 1024 return -1; |
1025 } else if(status){ | |
1026 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
1027 } | |
1028 } | |
1029 } | |
1030 | |
1031 return 0; | |
1032 } //FIXME cleanup like next | |
1033 | |
1034 /** | |
1035 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1036 */ | |
1037 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
1038 MpegEncContext * const s = &h->s; | |
1039 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
1040 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 1041 |
2392 | 1042 if(mode < 0 || mode > 6) { |
1043 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 | 1044 return -1; |
2392 | 1045 } |
2967 | 1046 |
1168 | 1047 if(!(h->top_samples_available&0x8000)){ |
1048 mode= top[ mode ]; | |
1049 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1050 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 | 1051 return -1; |
1052 } | |
1053 } | |
2967 | 1054 |
1168 | 1055 if(!(h->left_samples_available&0x8000)){ |
1056 mode= left[ mode ]; | |
1057 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1058 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 | 1059 return -1; |
2967 | 1060 } |
1168 | 1061 } |
1062 | |
1063 return mode; | |
1064 } | |
1065 | |
1066 /** | |
1067 * gets the predicted intra4x4 prediction mode. | |
1068 */ | |
1069 static inline int pred_intra_mode(H264Context *h, int n){ | |
1070 const int index8= scan8[n]; | |
1071 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1072 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1073 const int min= FFMIN(left, top); | |
1074 | |
1170 | 1075 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 1076 |
1077 if(min<0) return DC_PRED; | |
1078 else return min; | |
1079 } | |
1080 | |
1081 static inline void write_back_non_zero_count(H264Context *h){ | |
1082 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
|
1083 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
|
1084 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1085 h->non_zero_count[mb_xy][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
|
1086 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
|
1087 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
|
1088 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
|
1089 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
|
1090 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
|
1091 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 1092 |
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][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
|
1094 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
|
1095 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
|
1096 |
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][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
|
1098 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
|
1099 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 1100 |
1101 if(FRAME_MBAFF){ | |
1102 // store all luma nnzs, for deblocking | |
1103 int v = 0, i; | |
1104 for(i=0; i<16; i++) | |
1105 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
1106 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
1107 } | |
1168 | 1108 } |
1109 | |
1110 /** | |
1111 * gets the predicted number of non zero coefficients. | |
1112 * @param n block index | |
1113 */ | |
1114 static inline int pred_non_zero_count(H264Context *h, int n){ | |
1115 const int index8= scan8[n]; | |
1116 const int left= h->non_zero_count_cache[index8 - 1]; | |
1117 const int top = h->non_zero_count_cache[index8 - 8]; | |
1118 int i= left + top; | |
2967 | 1119 |
1168 | 1120 if(i<64) i= (i+1)>>1; |
1121 | |
1170 | 1122 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 1123 |
1124 return i&31; | |
1125 } | |
1126 | |
1169 | 1127 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
1128 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
1129 | |
3316 | 1130 /* there is no consistent mapping of mvs to neighboring locations that will |
1131 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
1132 if(FRAME_MBAFF){ | |
1133 MpegEncContext *s = &h->s; | |
3776 | 1134 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 1135 const int16_t *mv; |
1136 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
1137 *C = h->mv_cache[list][scan8[0]-2]; | |
1138 | |
1139 if(!MB_FIELD | |
1140 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
1141 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
1142 if(IS_INTERLACED(mb_types[topright_xy])){ | |
1143 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
1144 const int x4 = X4, y4 = Y4;\ | |
1145 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
1146 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
1147 return LIST_NOT_USED;\ | |
1148 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
1149 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
1150 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
1151 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
1152 | |
1153 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
1154 } | |
1155 } | |
1156 if(topright_ref == PART_NOT_AVAILABLE | |
1157 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
1158 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
1159 if(!MB_FIELD | |
1160 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
1161 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
1162 } | |
1163 if(MB_FIELD | |
1164 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
1165 && i >= scan8[0]+8){ | |
1166 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
1167 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
1168 } | |
1169 } | |
1170 #undef SET_DIAG_MV | |
1171 } | |
1172 | |
1169 | 1173 if(topright_ref != PART_NOT_AVAILABLE){ |
1174 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
1175 return topright_ref; | |
1176 }else{ | |
1170 | 1177 tprintf("topright MV not available\n"); |
1178 | |
1169 | 1179 *C= h->mv_cache[list][ i - 8 - 1 ]; |
1180 return h->ref_cache[list][ i - 8 - 1 ]; | |
1181 } | |
1182 } | |
1183 | |
1168 | 1184 /** |
1185 * gets the predicted MV. | |
1186 * @param n the block index | |
1187 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
1188 * @param mx the x component of the predicted motion vector | |
1189 * @param my the y component of the predicted motion vector | |
1190 */ | |
1191 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
1192 const int index8= scan8[n]; | |
1193 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
1194 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
1195 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
1196 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 1197 const int16_t * C; |
1198 int diagonal_ref, match_count; | |
1199 | |
1168 | 1200 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 1201 |
1168 | 1202 /* mv_cache |
2967 | 1203 B . . A T T T T |
1168 | 1204 U . . L . . , . |
1205 U . . L . . . . | |
1206 U . . L . . , . | |
1207 . . . L . . . . | |
1208 */ | |
1169 | 1209 |
1210 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
1211 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
|
1212 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 1213 if(match_count > 1){ //most common |
1214 *mx= mid_pred(A[0], B[0], C[0]); | |
1215 *my= mid_pred(A[1], B[1], C[1]); | |
1216 }else if(match_count==1){ | |
1217 if(left_ref==ref){ | |
1218 *mx= A[0]; | |
2967 | 1219 *my= A[1]; |
1169 | 1220 }else if(top_ref==ref){ |
1221 *mx= B[0]; | |
2967 | 1222 *my= B[1]; |
1169 | 1223 }else{ |
1224 *mx= C[0]; | |
2967 | 1225 *my= C[1]; |
1169 | 1226 } |
1227 }else{ | |
1228 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
1229 *mx= A[0]; | |
2967 | 1230 *my= A[1]; |
1168 | 1231 }else{ |
1232 *mx= mid_pred(A[0], B[0], C[0]); | |
1233 *my= mid_pred(A[1], B[1], C[1]); | |
1234 } | |
1169 | 1235 } |
2967 | 1236 |
1187 | 1237 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 | 1238 } |
1239 | |
1240 /** | |
1241 * gets the directionally predicted 16x8 MV. | |
1242 * @param n the block index | |
1243 * @param mx the x component of the predicted motion vector | |
1244 * @param my the y component of the predicted motion vector | |
1245 */ | |
1246 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1247 if(n==0){ | |
1248 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
1249 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
1250 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1251 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 | 1252 |
1168 | 1253 if(top_ref == ref){ |
1254 *mx= B[0]; | |
1255 *my= B[1]; | |
1256 return; | |
1257 } | |
1258 }else{ | |
1259 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
1260 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 1261 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1262 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 | 1263 |
1264 if(left_ref == ref){ | |
1265 *mx= A[0]; | |
1266 *my= A[1]; | |
1267 return; | |
1268 } | |
1269 } | |
1270 | |
1271 //RARE | |
1272 pred_motion(h, n, 4, list, ref, mx, my); | |
1273 } | |
1274 | |
1275 /** | |
1276 * gets the directionally predicted 8x16 MV. | |
1277 * @param n the block index | |
1278 * @param mx the x component of the predicted motion vector | |
1279 * @param my the y component of the predicted motion vector | |
1280 */ | |
1281 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1282 if(n==0){ | |
1283 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1284 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 1285 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1286 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 | 1287 |
1288 if(left_ref == ref){ | |
1289 *mx= A[0]; | |
1290 *my= A[1]; | |
1291 return; | |
1292 } | |
1293 }else{ | |
1169 | 1294 const int16_t * C; |
1295 int diagonal_ref; | |
1296 | |
1297 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 1298 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1299 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 | 1300 |
2967 | 1301 if(diagonal_ref == ref){ |
1168 | 1302 *mx= C[0]; |
1303 *my= C[1]; | |
1304 return; | |
1305 } | |
1306 } | |
1307 | |
1308 //RARE | |
1309 pred_motion(h, n, 2, list, ref, mx, my); | |
1310 } | |
1311 | |
1312 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1313 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1314 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1315 | |
2392 | 1316 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1317 |
1318 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1319 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1320 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 1321 |
1168 | 1322 *mx = *my = 0; |
1323 return; | |
1324 } | |
2967 | 1325 |
1168 | 1326 pred_motion(h, 0, 4, 0, 0, mx, my); |
1327 | |
1328 return; | |
1329 } | |
1330 | |
2396 | 1331 static inline void direct_dist_scale_factor(H264Context * const h){ |
1332 const int poc = h->s.current_picture_ptr->poc; | |
1333 const int poc1 = h->ref_list[1][0].poc; | |
1334 int i; | |
1335 for(i=0; i<h->ref_count[0]; i++){ | |
1336 int poc0 = h->ref_list[0][i].poc; | |
1337 int td = clip(poc1 - poc0, -128, 127); | |
1338 if(td == 0 /* FIXME || pic0 is a long-term ref */){ | |
1339 h->dist_scale_factor[i] = 256; | |
1340 }else{ | |
1341 int tb = clip(poc - poc0, -128, 127); | |
4001 | 1342 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2396 | 1343 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023); |
1344 } | |
1345 } | |
3316 | 1346 if(FRAME_MBAFF){ |
1347 for(i=0; i<h->ref_count[0]; i++){ | |
1348 h->dist_scale_factor_field[2*i] = | |
1349 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
1350 } | |
1351 } | |
2396 | 1352 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1353 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
|
1354 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1355 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
|
1356 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
|
1357 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1358 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1359 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1360 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1361 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1362 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1363 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
|
1364 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
|
1365 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
|
1366 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1367 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
|
1368 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1369 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1370 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
|
1371 const int poc = ref1->ref_poc[list][i]; |
3125 | 1372 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
|
1373 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
|
1374 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
|
1375 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
|
1376 break; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1377 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1378 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1379 } |
3316 | 1380 if(FRAME_MBAFF){ |
1381 for(list=0; list<2; list++){ | |
1382 for(i=0; i<ref1->ref_count[list]; i++){ | |
1383 j = h->map_col_to_list0[list][i]; | |
1384 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1385 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1386 } | |
1387 } | |
1388 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1389 } |
2396 | 1390 |
1391 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1392 MpegEncContext * const s = &h->s; | |
1393 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1394 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1395 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1396 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1397 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
|
1398 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1399 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
|
1400 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1401 const int is_b8x8 = IS_8X8(*mb_type); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
1402 unsigned int sub_mb_type; |
2396 | 1403 int i8, i4; |
1404 | |
3316 | 1405 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1406 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1407 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1408 * so we know exactly what block size to use */ | |
1409 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1410 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1411 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1412 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1413 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1414 }else{ | |
1415 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1416 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1417 } |
1418 if(!is_b8x8) | |
1419 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1420 if(MB_FIELD) |
1421 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1422 |
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
|
1423 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 | 1424 |
2396 | 1425 if(h->direct_spatial_mv_pred){ |
1426 int ref[2]; | |
1427 int mv[2][2]; | |
1428 int list; | |
1429 | |
3316 | 1430 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1431 | |
2396 | 1432 /* ref = min(neighbors) */ |
1433 for(list=0; list<2; list++){ | |
1434 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1435 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1436 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1437 if(refc == -2) | |
1438 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1439 ref[list] = refa; | |
1440 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1441 ref[list] = refb; | |
1442 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1443 ref[list] = refc; | |
1444 if(ref[list] < 0) | |
1445 ref[list] = -1; | |
1446 } | |
1447 | |
1448 if(ref[0] < 0 && ref[1] < 0){ | |
1449 ref[0] = ref[1] = 0; | |
1450 mv[0][0] = mv[0][1] = | |
1451 mv[1][0] = mv[1][1] = 0; | |
1452 }else{ | |
1453 for(list=0; list<2; list++){ | |
1454 if(ref[list] >= 0) | |
1455 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1456 else | |
1457 mv[list][0] = mv[list][1] = 0; | |
1458 } | |
1459 } | |
1460 | |
1461 if(ref[1] < 0){ | |
1462 *mb_type &= ~MB_TYPE_P0L1; | |
1463 sub_mb_type &= ~MB_TYPE_P0L1; | |
1464 }else if(ref[0] < 0){ | |
1465 *mb_type &= ~MB_TYPE_P0L0; | |
1466 sub_mb_type &= ~MB_TYPE_P0L0; | |
1467 } | |
1468 | |
1469 if(IS_16X16(*mb_type)){ | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1470 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
|
1471 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1472 if(!IS_INTRA(mb_type_col) |
4001 | 1473 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1474 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1475 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1476 if(ref[0] > 0) |
1477 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1478 else | |
1479 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1480 if(ref[1] > 0) | |
1481 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1482 else | |
1483 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1484 }else{ | |
1485 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1486 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1487 } | |
1488 }else{ | |
1489 for(i8=0; i8<4; i8++){ | |
1490 const int x8 = i8&1; | |
1491 const int y8 = i8>>1; | |
2967 | 1492 |
2396 | 1493 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1494 continue; | |
1495 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1496 |
2396 | 1497 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1498 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
|
1499 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
|
1500 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1501 |
2396 | 1502 /* col_zero_flag */ |
2967 | 1503 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1504 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1505 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1506 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1507 if(IS_SUB_8X8(sub_mb_type)){ |
1508 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1509 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1510 if(ref[0] == 0) |
1511 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1512 if(ref[1] == 0) | |
1513 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1514 } | |
1515 }else | |
2396 | 1516 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1517 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1518 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1519 if(ref[0] == 0) |
1520 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1521 if(ref[1] == 0) | |
1522 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1523 } | |
1524 } | |
1525 } | |
1526 } | |
1527 } | |
1528 }else{ /* direct temporal mv pred */ | |
3316 | 1529 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1530 const int *dist_scale_factor = h->dist_scale_factor; | |
1531 | |
1532 if(FRAME_MBAFF){ | |
1533 if(IS_INTERLACED(*mb_type)){ | |
1534 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1535 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1536 dist_scale_factor = h->dist_scale_factor_field; | |
1537 } | |
1538 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1539 /* FIXME assumes direct_8x8_inference == 1 */ | |
1540 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1541 int mb_types_col[2]; | |
1542 int y_shift; | |
1543 | |
1544 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1545 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1546 | (*mb_type & MB_TYPE_INTERLACED); | |
1547 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1548 | |
1549 if(IS_INTERLACED(*mb_type)){ | |
1550 /* frame to field scaling */ | |
1551 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1552 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1553 if(s->mb_y&1){ | |
1554 l1ref0 -= 2*h->b8_stride; | |
1555 l1ref1 -= 2*h->b8_stride; | |
1556 l1mv0 -= 4*h->b_stride; | |
1557 l1mv1 -= 4*h->b_stride; | |
1558 } | |
1559 y_shift = 0; | |
1560 | |
1561 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1562 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1563 && !is_b8x8) | |
1564 *mb_type |= MB_TYPE_16x8; | |
1565 else | |
1566 *mb_type |= MB_TYPE_8x8; | |
1567 }else{ | |
1568 /* field to frame scaling */ | |
1569 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1570 * but in MBAFF, top and bottom POC are equal */ | |
1571 int dy = (s->mb_y&1) ? 1 : 2; | |
1572 mb_types_col[0] = | |
1573 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1574 l1ref0 += dy*h->b8_stride; | |
1575 l1ref1 += dy*h->b8_stride; | |
1576 l1mv0 += 2*dy*h->b_stride; | |
1577 l1mv1 += 2*dy*h->b_stride; | |
1578 y_shift = 2; | |
1579 | |
1580 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1581 && !is_b8x8) | |
1582 *mb_type |= MB_TYPE_16x16; | |
1583 else | |
1584 *mb_type |= MB_TYPE_8x8; | |
1585 } | |
1586 | |
1587 for(i8=0; i8<4; i8++){ | |
1588 const int x8 = i8&1; | |
1589 const int y8 = i8>>1; | |
1590 int ref0, scale; | |
1591 const int16_t (*l1mv)[2]= l1mv0; | |
1592 | |
1593 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1594 continue; | |
1595 h->sub_mb_type[i8] = sub_mb_type; | |
1596 | |
1597 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1598 if(IS_INTRA(mb_types_col[y8])){ | |
1599 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1600 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1601 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1602 continue; | |
1603 } | |
1604 | |
1605 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1606 if(ref0 >= 0) | |
1607 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1608 else{ | |
1609 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1610 l1mv= l1mv1; | |
1611 } | |
1612 scale = dist_scale_factor[ref0]; | |
1613 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1614 | |
1615 { | |
1616 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1617 int my_col = (mv_col[1]<<y_shift)/2; | |
1618 int mx = (scale * mv_col[0] + 128) >> 8; | |
1619 int my = (scale * my_col + 128) >> 8; | |
1620 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1621 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1622 } | |
1623 } | |
1624 return; | |
1625 } | |
1626 } | |
1627 | |
1628 /* one-to-one mv scaling */ | |
1629 | |
2396 | 1630 if(IS_16X16(*mb_type)){ |
1631 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); | |
1632 if(IS_INTRA(mb_type_col)){ | |
1633 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1634 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1635 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1636 }else{ | |
3316 | 1637 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1638 : map_col_to_list0[1][l1ref1[0]]; | |
1639 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
|
1640 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1641 int mv_l0[2]; |
3316 | 1642 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1643 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1644 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1); |
1645 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4); | |
1646 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); | |
1647 } | |
1648 }else{ | |
1649 for(i8=0; i8<4; i8++){ | |
1650 const int x8 = i8&1; | |
1651 const int y8 = i8>>1; | |
3316 | 1652 int ref0, scale; |
2834 | 1653 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
|
1654 |
2396 | 1655 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1656 continue; | |
1657 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1658 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1659 if(IS_INTRA(mb_type_col)){ |
1660 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1661 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1662 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1663 continue; | |
1664 } | |
2967 | 1665 |
2396 | 1666 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
|
1667 if(ref0 >= 0) |
3316 | 1668 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
|
1669 else{ |
3316 | 1670 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
|
1671 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1672 } |
3316 | 1673 scale = dist_scale_factor[ref0]; |
2967 | 1674 |
2396 | 1675 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1676 if(IS_SUB_8X8(sub_mb_type)){ |
1677 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1678 int mx = (scale * mv_col[0] + 128) >> 8; |
1679 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1680 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1681 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1682 }else | |
2396 | 1683 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
|
1684 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1685 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1686 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1687 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1688 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1689 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1690 } | |
1691 } | |
1692 } | |
1693 } | |
1694 } | |
1695 | |
1168 | 1696 static inline void write_back_motion(H264Context *h, int mb_type){ |
1697 MpegEncContext * const s = &h->s; | |
1698 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1699 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1700 int list; | |
1701 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1702 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1703 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
|
1704 |
1168 | 1705 for(list=0; list<2; list++){ |
1706 int y; | |
3212 | 1707 if(!USES_LIST(mb_type, list)) |
2396 | 1708 continue; |
2967 | 1709 |
1168 | 1710 for(y=0; y<4; y++){ |
1711 *(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]; | |
1712 *(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]; | |
1713 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1714 if( h->pps.cabac ) { |
3927 | 1715 if(IS_SKIP(mb_type)) |
1716 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1717 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1718 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
|
1719 *(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
|
1720 *(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
|
1721 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1722 } |
3212 | 1723 |
1724 { | |
3776 | 1725 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1726 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1727 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1728 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1729 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1730 } |
1731 } | |
2967 | 1732 |
2396 | 1733 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1734 if(IS_8X8(mb_type)){ | |
3212 | 1735 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1736 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1737 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1738 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1739 } |
1740 } | |
1168 | 1741 } |
1742 | |
1743 /** | |
1744 * Decodes a network abstraction layer unit. | |
1745 * @param consumed is the number of bytes used as input | |
1746 * @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
|
1747 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1748 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1749 */ |
1750 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1751 int i, si, di; | |
1752 uint8_t *dst; | |
1753 | |
2979 | 1754 // src[0]&0x80; //forbidden bit |
1168 | 1755 h->nal_ref_idc= src[0]>>5; |
1756 h->nal_unit_type= src[0]&0x1F; | |
1757 | |
1758 src++; length--; | |
2967 | 1759 #if 0 |
1168 | 1760 for(i=0; i<length; i++) |
1761 printf("%2X ", src[i]); | |
1762 #endif | |
1763 for(i=0; i+1<length; i+=2){ | |
1764 if(src[i]) continue; | |
1765 if(i>0 && src[i-1]==0) i--; | |
1766 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1767 if(src[i+2]!=3){ | |
1768 /* startcode, so we must be past the end */ | |
1769 length=i; | |
1770 } | |
1771 break; | |
1772 } | |
1773 } | |
1774 | |
1775 if(i>=length-1){ //no escaped 0 | |
1776 *dst_length= length; | |
1777 *consumed= length+1; //+1 for the header | |
2967 | 1778 return src; |
1168 | 1779 } |
1780 | |
1781 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1782 dst= h->rbsp_buffer; | |
1783 | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1784 if (dst == NULL){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1785 return NULL; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1786 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
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 | |
1811 /** | |
1812 * identifies the exact end of the bitstream | |
1813 * @return the length of the trailing, or 0 if damaged | |
1814 */ | |
1815 static int decode_rbsp_trailing(uint8_t *src){ | |
1816 int v= *src; | |
1817 int r; | |
1818 | |
1170 | 1819 tprintf("rbsp trailing %X\n", v); |
1168 | 1820 |
1821 for(r=1; r<9; r++){ | |
1822 if(v&1) return r; | |
1823 v>>=1; | |
1824 } | |
1825 return 0; | |
1826 } | |
1827 | |
1828 /** | |
1829 * idct tranforms the 16 dc values and dequantize them. | |
1830 * @param qp quantization parameter | |
1831 */ | |
2919 | 1832 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1833 #define stride 16 |
1834 int i; | |
1835 int temp[16]; //FIXME check if this is a good idea | |
1836 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1837 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1838 | |
1839 //memset(block, 64, 2*256); | |
1840 //return; | |
1841 for(i=0; i<4; i++){ | |
1842 const int offset= y_offset[i]; | |
1843 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1844 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1845 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1846 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1847 | |
1848 temp[4*i+0]= z0+z3; | |
1849 temp[4*i+1]= z1+z2; | |
1850 temp[4*i+2]= z1-z2; | |
1851 temp[4*i+3]= z0-z3; | |
1852 } | |
1853 | |
1854 for(i=0; i<4; i++){ | |
1855 const int offset= x_offset[i]; | |
1856 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1857 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1858 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1859 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1860 | |
2919 | 1861 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1862 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1863 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1864 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1865 } |
1866 } | |
1867 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1868 #if 0 |
1168 | 1869 /** |
1870 * dct tranforms the 16 dc values. | |
1871 * @param qp quantization parameter ??? FIXME | |
1872 */ | |
1873 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1874 // const int qmul= dequant_coeff[qp][0]; | |
1875 int i; | |
1876 int temp[16]; //FIXME check if this is a good idea | |
1877 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1878 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1879 | |
1880 for(i=0; i<4; i++){ | |
1881 const int offset= y_offset[i]; | |
1882 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1883 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1884 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1885 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1886 | |
1887 temp[4*i+0]= z0+z3; | |
1888 temp[4*i+1]= z1+z2; | |
1889 temp[4*i+2]= z1-z2; | |
1890 temp[4*i+3]= z0-z3; | |
1891 } | |
1892 | |
1893 for(i=0; i<4; i++){ | |
1894 const int offset= x_offset[i]; | |
1895 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1896 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1897 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1898 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1899 | |
1900 block[stride*0 +offset]= (z0 + z3)>>1; | |
1901 block[stride*2 +offset]= (z1 + z2)>>1; | |
1902 block[stride*8 +offset]= (z1 - z2)>>1; | |
1903 block[stride*10+offset]= (z0 - z3)>>1; | |
1904 } | |
1905 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1906 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1907 |
1168 | 1908 #undef xStride |
1909 #undef stride | |
1910 | |
2919 | 1911 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1912 const int stride= 16*2; |
1913 const int xStride= 16; | |
1914 int a,b,c,d,e; | |
1915 | |
1916 a= block[stride*0 + xStride*0]; | |
1917 b= block[stride*0 + xStride*1]; | |
1918 c= block[stride*1 + xStride*0]; | |
1919 d= block[stride*1 + xStride*1]; | |
1920 | |
1921 e= a-b; | |
1922 a= a+b; | |
1923 b= c-d; | |
1924 c= c+d; | |
1925 | |
2919 | 1926 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1927 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1928 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1929 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1930 } |
1931 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1932 #if 0 |
1168 | 1933 static void chroma_dc_dct_c(DCTELEM *block){ |
1934 const int stride= 16*2; | |
1935 const int xStride= 16; | |
1936 int a,b,c,d,e; | |
1937 | |
1938 a= block[stride*0 + xStride*0]; | |
1939 b= block[stride*0 + xStride*1]; | |
1940 c= block[stride*1 + xStride*0]; | |
1941 d= block[stride*1 + xStride*1]; | |
1942 | |
1943 e= a-b; | |
1944 a= a+b; | |
1945 b= c-d; | |
1946 c= c+d; | |
1947 | |
1948 block[stride*0 + xStride*0]= (a+c); | |
1949 block[stride*0 + xStride*1]= (e+b); | |
1950 block[stride*1 + xStride*0]= (a-c); | |
1951 block[stride*1 + xStride*1]= (e-b); | |
1952 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1953 #endif |
1168 | 1954 |
1955 /** | |
1956 * gets the chroma qp. | |
1957 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1958 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 1959 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1960 return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 1961 } |
1962 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1963 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close |
1168 | 1964 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away) |
1965 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){ | |
1966 int i; | |
1967 const int * const quant_table= quant_coeff[qscale]; | |
1968 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1969 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1970 const unsigned int threshold2= (threshold1<<1); | |
1971 int last_non_zero; | |
1972 | |
1973 if(seperate_dc){ | |
1974 if(qscale<=18){ | |
1975 //avoid overflows | |
1976 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1977 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1978 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1979 | |
1980 int level= block[0]*quant_coeff[qscale+18][0]; | |
1981 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1982 if(level>0){ | |
1983 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1984 block[0]= level; | |
1985 }else{ | |
1986 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1987 block[0]= -level; | |
1988 } | |
1989 // last_non_zero = i; | |
1990 }else{ | |
1991 block[0]=0; | |
1992 } | |
1993 }else{ | |
1994 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1995 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1996 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1997 | |
1998 int level= block[0]*quant_table[0]; | |
1999 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
2000 if(level>0){ | |
2001 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
2002 block[0]= level; | |
2003 }else{ | |
2004 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
2005 block[0]= -level; | |
2006 } | |
2007 // last_non_zero = i; | |
2008 }else{ | |
2009 block[0]=0; | |
2010 } | |
2011 } | |
2012 last_non_zero= 0; | |
2013 i=1; | |
2014 }else{ | |
2015 last_non_zero= -1; | |
2016 i=0; | |
2017 } | |
2018 | |
2019 for(; i<16; i++){ | |
2020 const int j= scantable[i]; | |
2021 int level= block[j]*quant_table[j]; | |
2022 | |
2023 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
2024 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
2025 if(((unsigned)(level+threshold1))>threshold2){ | |
2026 if(level>0){ | |
2027 level= (bias + level)>>QUANT_SHIFT; | |
2028 block[j]= level; | |
2029 }else{ | |
2030 level= (bias - level)>>QUANT_SHIFT; | |
2031 block[j]= -level; | |
2032 } | |
2033 last_non_zero = i; | |
2034 }else{ | |
2035 block[j]=0; | |
2036 } | |
2037 } | |
2038 | |
2039 return last_non_zero; | |
2040 } | |
2041 | |
2042 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
2043 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2044 ((uint32_t*)(src+0*stride))[0]= a; | |
2045 ((uint32_t*)(src+1*stride))[0]= a; | |
2046 ((uint32_t*)(src+2*stride))[0]= a; | |
2047 ((uint32_t*)(src+3*stride))[0]= a; | |
2048 } | |
2049 | |
2050 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
2051 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
2052 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
2053 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
2054 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
2055 } | |
2056 | |
2057 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2058 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
2059 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 2060 |
2061 ((uint32_t*)(src+0*stride))[0]= | |
2062 ((uint32_t*)(src+1*stride))[0]= | |
2063 ((uint32_t*)(src+2*stride))[0]= | |
2064 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2065 } |
2066 | |
2067 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2068 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 2069 |
2070 ((uint32_t*)(src+0*stride))[0]= | |
2071 ((uint32_t*)(src+1*stride))[0]= | |
2072 ((uint32_t*)(src+2*stride))[0]= | |
2073 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2074 } |
2075 | |
2076 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2077 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 2078 |
2079 ((uint32_t*)(src+0*stride))[0]= | |
2080 ((uint32_t*)(src+1*stride))[0]= | |
2081 ((uint32_t*)(src+2*stride))[0]= | |
2082 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2083 } |
2084 | |
2085 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2086 ((uint32_t*)(src+0*stride))[0]= |
2087 ((uint32_t*)(src+1*stride))[0]= | |
2088 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 2089 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
2090 } | |
2091 | |
2092 | |
2093 #define LOAD_TOP_RIGHT_EDGE\ | |
2094 const int t4= topright[0];\ | |
2095 const int t5= topright[1];\ | |
2096 const int t6= topright[2];\ | |
2097 const int t7= topright[3];\ | |
2098 | |
2099 #define LOAD_LEFT_EDGE\ | |
2100 const int l0= src[-1+0*stride];\ | |
2101 const int l1= src[-1+1*stride];\ | |
2102 const int l2= src[-1+2*stride];\ | |
2103 const int l3= src[-1+3*stride];\ | |
2104 | |
2105 #define LOAD_TOP_EDGE\ | |
2106 const int t0= src[ 0-1*stride];\ | |
2107 const int t1= src[ 1-1*stride];\ | |
2108 const int t2= src[ 2-1*stride];\ | |
2109 const int t3= src[ 3-1*stride];\ | |
2110 | |
2111 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2112 const int lt= src[-1-1*stride]; | |
2113 LOAD_TOP_EDGE | |
2114 LOAD_LEFT_EDGE | |
2115 | |
2967 | 2116 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 2117 src[0+2*stride]= |
2967 | 2118 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 2119 src[0+1*stride]= |
2120 src[1+2*stride]= | |
2967 | 2121 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 2122 src[0+0*stride]= |
2123 src[1+1*stride]= | |
2124 src[2+2*stride]= | |
2967 | 2125 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 2126 src[1+0*stride]= |
2127 src[2+1*stride]= | |
2128 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2129 src[2+0*stride]= | |
2130 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2131 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 2132 } |
1168 | 2133 |
2134 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2135 LOAD_TOP_EDGE |
2136 LOAD_TOP_RIGHT_EDGE | |
2137 // LOAD_LEFT_EDGE | |
1168 | 2138 |
2139 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
2140 src[1+0*stride]= | |
2141 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
2142 src[2+0*stride]= | |
2143 src[1+1*stride]= | |
2144 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
2145 src[3+0*stride]= | |
2146 src[2+1*stride]= | |
2147 src[1+2*stride]= | |
2148 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
2149 src[3+1*stride]= | |
2150 src[2+2*stride]= | |
2151 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
2152 src[3+2*stride]= | |
2153 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
2154 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 2155 } |
1168 | 2156 |
2157 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2158 const int lt= src[-1-1*stride]; | |
2967 | 2159 LOAD_TOP_EDGE |
2160 LOAD_LEFT_EDGE | |
1168 | 2161 const __attribute__((unused)) int unu= l3; |
2162 | |
2163 src[0+0*stride]= | |
2164 src[1+2*stride]=(lt + t0 + 1)>>1; | |
2165 src[1+0*stride]= | |
2166 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
2167 src[2+0*stride]= | |
2168 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
2169 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
2170 src[0+1*stride]= | |
2171 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2172 src[1+1*stride]= | |
2173 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2174 src[2+1*stride]= | |
2175 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2176 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2177 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2178 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 2179 } |
1168 | 2180 |
2181 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2182 LOAD_TOP_EDGE |
2183 LOAD_TOP_RIGHT_EDGE | |
1168 | 2184 const __attribute__((unused)) int unu= t7; |
2185 | |
2186 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
2187 src[1+0*stride]= | |
2188 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
2189 src[2+0*stride]= | |
2190 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
2191 src[3+0*stride]= | |
2192 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
2193 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
2194 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2195 src[1+1*stride]= | |
2196 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2197 src[2+1*stride]= | |
2198 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
2199 src[3+1*stride]= | |
2200 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
2201 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 2202 } |
1168 | 2203 |
2204 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2205 LOAD_LEFT_EDGE |
1168 | 2206 |
2207 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
2208 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2209 src[2+0*stride]= | |
2210 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
2211 src[3+0*stride]= | |
2212 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
2213 src[2+1*stride]= | |
2214 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
2215 src[3+1*stride]= | |
2216 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
2217 src[3+2*stride]= | |
2218 src[1+3*stride]= | |
2219 src[0+3*stride]= | |
2220 src[2+2*stride]= | |
2221 src[2+3*stride]= | |
2222 src[3+3*stride]=l3; | |
1282 | 2223 } |
2967 | 2224 |
1168 | 2225 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
2226 const int lt= src[-1-1*stride]; | |
2967 | 2227 LOAD_TOP_EDGE |
2228 LOAD_LEFT_EDGE | |
1168 | 2229 const __attribute__((unused)) int unu= t3; |
2230 | |
2231 src[0+0*stride]= | |
2232 src[2+1*stride]=(lt + l0 + 1)>>1; | |
2233 src[1+0*stride]= | |
2234 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2235 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2236 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2237 src[0+1*stride]= | |
2238 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
2239 src[1+1*stride]= | |
2240 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2241 src[0+2*stride]= | |
2242 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
2243 src[1+2*stride]= | |
2244 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2245 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
2246 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 2247 } |
1168 | 2248 |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2249 void ff_pred16x16_vertical_c(uint8_t *src, int stride){ |
1168 | 2250 int i; |
2251 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2252 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2253 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
2254 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 2255 |
1168 | 2256 for(i=0; i<16; i++){ |
2257 ((uint32_t*)(src+i*stride))[0]= a; | |
2258 ((uint32_t*)(src+i*stride))[1]= b; | |
2259 ((uint32_t*)(src+i*stride))[2]= c; | |
2260 ((uint32_t*)(src+i*stride))[3]= d; | |
2261 } | |
2262 } | |
2263 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2264 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){ |
1168 | 2265 int i; |
2266 | |
2267 for(i=0; i<16; i++){ | |
2268 ((uint32_t*)(src+i*stride))[0]= | |
2269 ((uint32_t*)(src+i*stride))[1]= | |
2270 ((uint32_t*)(src+i*stride))[2]= | |
2271 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
2272 } | |
2273 } | |
2274 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2275 void ff_pred16x16_dc_c(uint8_t *src, int stride){ |
1168 | 2276 int i, dc=0; |
2277 | |
2278 for(i=0;i<16; i++){ | |
2279 dc+= src[-1+i*stride]; | |
2280 } | |
2967 | 2281 |
1168 | 2282 for(i=0;i<16; i++){ |
2283 dc+= src[i-stride]; | |
2284 } | |
2285 | |
2286 dc= 0x01010101*((dc + 16)>>5); | |
2287 | |
2288 for(i=0; i<16; i++){ | |
2289 ((uint32_t*)(src+i*stride))[0]= | |
2290 ((uint32_t*)(src+i*stride))[1]= | |
2291 ((uint32_t*)(src+i*stride))[2]= | |
2292 ((uint32_t*)(src+i*stride))[3]= dc; | |
2293 } | |
2294 } | |
2295 | |
2296 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
2297 int i, dc=0; | |
2298 | |
2299 for(i=0;i<16; i++){ | |
2300 dc+= src[-1+i*stride]; | |
2301 } | |
2967 | 2302 |
1168 | 2303 dc= 0x01010101*((dc + 8)>>4); |
2304 | |
2305 for(i=0; i<16; i++){ | |
2306 ((uint32_t*)(src+i*stride))[0]= | |
2307 ((uint32_t*)(src+i*stride))[1]= | |
2308 ((uint32_t*)(src+i*stride))[2]= | |
2309 ((uint32_t*)(src+i*stride))[3]= dc; | |
2310 } | |
2311 } | |
2312 | |
2313 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
2314 int i, dc=0; | |
2315 | |
2316 for(i=0;i<16; i++){ | |
2317 dc+= src[i-stride]; | |
2318 } | |
2319 dc= 0x01010101*((dc + 8)>>4); | |
2320 | |
2321 for(i=0; i<16; i++){ | |
2322 ((uint32_t*)(src+i*stride))[0]= | |
2323 ((uint32_t*)(src+i*stride))[1]= | |
2324 ((uint32_t*)(src+i*stride))[2]= | |
2325 ((uint32_t*)(src+i*stride))[3]= dc; | |
2326 } | |
2327 } | |
2328 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2329 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){ |
1168 | 2330 int i; |
2331 | |
2332 for(i=0; i<16; i++){ | |
2333 ((uint32_t*)(src+i*stride))[0]= | |
2334 ((uint32_t*)(src+i*stride))[1]= | |
2335 ((uint32_t*)(src+i*stride))[2]= | |
2336 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
2337 } | |
2338 } | |
2339 | |
1234 | 2340 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
|
2341 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2342 int a; |
4176 | 2343 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2344 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
|
2345 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
|
2346 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
|
2347 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
|
2348 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
|
2349 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
|
2350 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2351 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
|
2352 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
|
2353 } |
1234 | 2354 if(svq3){ |
2355 H = ( 5*(H/4) ) / 16; | |
2356 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2357 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2358 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2359 i = H; H = V; V = i; |
1234 | 2360 }else{ |
2361 H = ( 5*H+32 ) >> 6; | |
2362 V = ( 5*V+32 ) >> 6; | |
2363 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2364 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2365 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
|
2366 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
|
2367 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2368 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2369 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
|
2370 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
|
2371 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
|
2372 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
|
2373 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
|
2374 b += 4*H; |
1168 | 2375 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2376 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2377 } |
1168 | 2378 } |
2379 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2380 void ff_pred16x16_plane_c(uint8_t *src, int stride){ |
1234 | 2381 pred16x16_plane_compat_c(src, stride, 0); |
2382 } | |
2383 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2384 void ff_pred8x8_vertical_c(uint8_t *src, int stride){ |
1168 | 2385 int i; |
2386 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2387 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2388 |
1168 | 2389 for(i=0; i<8; i++){ |
2390 ((uint32_t*)(src+i*stride))[0]= a; | |
2391 ((uint32_t*)(src+i*stride))[1]= b; | |
2392 } | |
2393 } | |
2394 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2395 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){ |
1168 | 2396 int i; |
2397 | |
2398 for(i=0; i<8; i++){ | |
2399 ((uint32_t*)(src+i*stride))[0]= | |
2400 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2401 } | |
2402 } | |
2403 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2404 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){ |
1168 | 2405 int i; |
2406 | |
2755 | 2407 for(i=0; i<8; i++){ |
2967 | 2408 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2409 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2410 } | |
2411 } | |
2412 | |
2413 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2414 int i; | |
2415 int dc0, dc2; | |
2416 | |
2417 dc0=dc2=0; | |
2418 for(i=0;i<4; i++){ | |
2419 dc0+= src[-1+i*stride]; | |
2420 dc2+= src[-1+(i+4)*stride]; | |
2421 } | |
2422 dc0= 0x01010101*((dc0 + 2)>>2); | |
2423 dc2= 0x01010101*((dc2 + 2)>>2); | |
2424 | |
2425 for(i=0; i<4; i++){ | |
2426 ((uint32_t*)(src+i*stride))[0]= | |
2427 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2428 } | |
2429 for(i=4; i<8; i++){ | |
2430 ((uint32_t*)(src+i*stride))[0]= | |
2431 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2432 } | |
2433 } | |
2434 | |
2435 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2436 int i; | |
2437 int dc0, dc1; | |
2438 | |
2439 dc0=dc1=0; | |
2440 for(i=0;i<4; i++){ | |
2441 dc0+= src[i-stride]; | |
2442 dc1+= src[4+i-stride]; | |
2443 } | |
2444 dc0= 0x01010101*((dc0 + 2)>>2); | |
2445 dc1= 0x01010101*((dc1 + 2)>>2); | |
2446 | |
2447 for(i=0; i<4; i++){ | |
2448 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2449 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2450 } | |
2451 for(i=4; i<8; i++){ | |
2452 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2453 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2454 } | |
2455 } | |
2456 | |
2457 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2458 void ff_pred8x8_dc_c(uint8_t *src, int stride){ |
1168 | 2459 int i; |
2460 int dc0, dc1, dc2, dc3; | |
2461 | |
2462 dc0=dc1=dc2=0; | |
2463 for(i=0;i<4; i++){ | |
2464 dc0+= src[-1+i*stride] + src[i-stride]; | |
2465 dc1+= src[4+i-stride]; | |
2466 dc2+= src[-1+(i+4)*stride]; | |
2467 } | |
2468 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2469 dc0= 0x01010101*((dc0 + 4)>>3); | |
2470 dc1= 0x01010101*((dc1 + 2)>>2); | |
2471 dc2= 0x01010101*((dc2 + 2)>>2); | |
2472 | |
2473 for(i=0; i<4; i++){ | |
2474 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2475 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2476 } | |
2477 for(i=4; i<8; i++){ | |
2478 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2479 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2480 } | |
2481 } | |
2482 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2483 void ff_pred8x8_plane_c(uint8_t *src, int stride){ |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2484 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2485 int a; |
4176 | 2486 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2487 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
|
2488 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
|
2489 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
|
2490 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
|
2491 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
|
2492 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
|
2493 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2494 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
|
2495 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
|
2496 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2497 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2498 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2499 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2500 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
|
2501 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
|
2502 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2503 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2504 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2505 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
|
2506 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
|
2507 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
|
2508 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
|
2509 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
|
2510 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
|
2511 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
|
2512 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2513 } |
1168 | 2514 } |
2515 | |
2755 | 2516 #define SRC(x,y) src[(x)+(y)*stride] |
2517 #define PL(y) \ | |
2518 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2519 #define PREDICT_8x8_LOAD_LEFT \ | |
2520 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2521 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2522 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2523 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2524 |
2525 #define PT(x) \ | |
2526 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2527 #define PREDICT_8x8_LOAD_TOP \ | |
2528 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2529 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2530 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2531 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2532 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2533 |
2534 #define PTR(x) \ | |
2535 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2536 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2537 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2538 if(has_topright) { \ | |
2539 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2540 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2541 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2542 | |
2543 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2544 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2545 |
2546 #define PREDICT_8x8_DC(v) \ | |
2547 int y; \ | |
2548 for( y = 0; y < 8; y++ ) { \ | |
2549 ((uint32_t*)src)[0] = \ | |
2550 ((uint32_t*)src)[1] = v; \ | |
2551 src += stride; \ | |
2552 } | |
2553 | |
2554 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2555 { | |
2556 PREDICT_8x8_DC(0x80808080); | |
2557 } | |
2558 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2559 { | |
2560 PREDICT_8x8_LOAD_LEFT; | |
2561 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2562 PREDICT_8x8_DC(dc); | |
2563 } | |
2564 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2565 { | |
2566 PREDICT_8x8_LOAD_TOP; | |
2567 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2568 PREDICT_8x8_DC(dc); | |
2569 } | |
2570 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2571 { | |
2572 PREDICT_8x8_LOAD_LEFT; | |
2573 PREDICT_8x8_LOAD_TOP; | |
2574 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2575 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2576 PREDICT_8x8_DC(dc); | |
2577 } | |
2578 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2579 { | |
2580 PREDICT_8x8_LOAD_LEFT; | |
2581 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2582 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2583 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2584 #undef ROW | |
2585 } | |
2586 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2587 { | |
2588 int y; | |
2589 PREDICT_8x8_LOAD_TOP; | |
2590 src[0] = t0; | |
2591 src[1] = t1; | |
2592 src[2] = t2; | |
2593 src[3] = t3; | |
2594 src[4] = t4; | |
2595 src[5] = t5; | |
2596 src[6] = t6; | |
2597 src[7] = t7; | |
2598 for( y = 1; y < 8; y++ ) | |
2599 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2600 } | |
2601 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2602 { | |
2603 PREDICT_8x8_LOAD_TOP; | |
2604 PREDICT_8x8_LOAD_TOPRIGHT; | |
2605 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2606 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2607 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2608 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2609 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2610 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2611 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; | |
2612 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; | |
2613 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; | |
2614 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2615 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2616 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2617 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2618 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2619 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2620 } | |
2621 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2622 { | |
2623 PREDICT_8x8_LOAD_TOP; | |
2624 PREDICT_8x8_LOAD_LEFT; | |
2625 PREDICT_8x8_LOAD_TOPLEFT; | |
2626 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2627 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2628 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2629 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2630 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2631 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2632 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; | |
2633 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; | |
2634 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; | |
2635 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2636 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2637 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2638 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2639 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2640 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2641 |
2755 | 2642 } |
2643 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2644 { | |
2645 PREDICT_8x8_LOAD_TOP; | |
2646 PREDICT_8x8_LOAD_LEFT; | |
2647 PREDICT_8x8_LOAD_TOPLEFT; | |
2648 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2649 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2650 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2651 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2652 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2653 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2654 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2655 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2656 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2657 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2658 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2659 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2660 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2661 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2662 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2663 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2664 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2665 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2666 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2667 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2668 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2669 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2670 } | |
2671 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2672 { | |
2673 PREDICT_8x8_LOAD_TOP; | |
2674 PREDICT_8x8_LOAD_LEFT; | |
2675 PREDICT_8x8_LOAD_TOPLEFT; | |
2676 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2677 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2678 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2679 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2680 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2681 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2682 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2683 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2684 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2685 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2686 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2687 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2688 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2689 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2690 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2691 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2692 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2693 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2694 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2695 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2696 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2697 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2698 } | |
2699 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2700 { | |
2701 PREDICT_8x8_LOAD_TOP; | |
2702 PREDICT_8x8_LOAD_TOPRIGHT; | |
2703 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2704 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2705 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2706 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2707 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2708 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2709 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2710 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2711 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2712 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2713 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2714 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2715 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2716 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2717 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2718 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2719 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2720 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2721 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2722 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2723 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2724 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2725 } | |
2726 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2727 { | |
2728 PREDICT_8x8_LOAD_LEFT; | |
2729 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2730 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2731 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2732 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2733 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2734 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2735 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2736 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2737 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2738 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2739 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2740 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2741 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2742 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2743 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2744 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2745 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2746 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2747 } | |
2748 #undef PREDICT_8x8_LOAD_LEFT | |
2749 #undef PREDICT_8x8_LOAD_TOP | |
2750 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2751 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2752 #undef PREDICT_8x8_DC | |
2753 #undef PTR | |
2754 #undef PT | |
2755 #undef PL | |
2756 #undef SRC | |
2757 | |
1168 | 2758 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2759 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2760 int src_x_offset, int src_y_offset, | |
2761 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2762 MpegEncContext * const s = &h->s; | |
2763 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2764 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2765 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2766 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2767 uint8_t * src_cb, * src_cr; | |
2768 int extra_width= h->emu_edge_width; | |
2769 int extra_height= h->emu_edge_height; | |
1168 | 2770 int emu=0; |
2771 const int full_mx= mx>>2; | |
2772 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2773 const int pic_width = 16*s->mb_width; |
3316 | 2774 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2775 |
4390 | 2776 if(!pic->data[0]) //FIXME this is unacceptable, some senseable error concealment must be done for missing reference frames |
3125 | 2777 return; |
2967 | 2778 |
1168 | 2779 if(mx&7) extra_width -= 3; |
2780 if(my&7) extra_height -= 3; | |
2967 | 2781 |
2782 if( full_mx < 0-extra_width | |
2783 || full_my < 0-extra_height | |
2784 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2785 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2786 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); |
2787 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2788 emu=1; |
2789 } | |
2967 | 2790 |
3316 | 2791 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2792 if(!square){ |
3316 | 2793 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2794 } |
2967 | 2795 |
1168 | 2796 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2797 |
3316 | 2798 if(MB_MBAFF){ |
2799 // chroma offset when predicting from a field of opposite parity | |
2800 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2801 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2802 } | |
2803 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2804 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2805 |
2806 if(emu){ | |
3316 | 2807 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); |
2808 src_cb= s->edge_emu_buffer; | |
2809 } | |
2810 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2811 | |
2812 if(emu){ | |
2813 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 | 2814 src_cr= s->edge_emu_buffer; |
2815 } | |
3316 | 2816 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2817 } |
2818 | |
2415 | 2819 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2820 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2821 int x_offset, int y_offset, | |
2822 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2823 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2824 int list0, int list1){ | |
2825 MpegEncContext * const s = &h->s; | |
2826 qpel_mc_func *qpix_op= qpix_put; | |
2827 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2828 |
3316 | 2829 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2830 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2831 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2832 x_offset += 8*s->mb_x; |
3316 | 2833 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2834 |
1168 | 2835 if(list0){ |
1169 | 2836 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2837 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2838 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2839 qpix_op, chroma_op); | |
2840 | |
2841 qpix_op= qpix_avg; | |
2842 chroma_op= chroma_avg; | |
2843 } | |
2844 | |
2845 if(list1){ | |
1169 | 2846 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2847 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2848 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2849 qpix_op, chroma_op); | |
2850 } | |
2851 } | |
2852 | |
2415 | 2853 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2854 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2855 int x_offset, int y_offset, | |
2856 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2857 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2858 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2859 int list0, int list1){ | |
2860 MpegEncContext * const s = &h->s; | |
2861 | |
3316 | 2862 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2863 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2864 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2865 x_offset += 8*s->mb_x; |
3316 | 2866 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2867 |
2415 | 2868 if(list0 && list1){ |
2869 /* don't optimize for luma-only case, since B-frames usually | |
2870 * use implicit weights => chroma too. */ | |
2871 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2872 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2873 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2874 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2875 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2876 | |
2877 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2878 dest_y, dest_cb, dest_cr, | |
2879 x_offset, y_offset, qpix_put, chroma_put); | |
2880 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2881 tmp_y, tmp_cb, tmp_cr, | |
2882 x_offset, y_offset, qpix_put, chroma_put); | |
2883 | |
2884 if(h->use_weight == 2){ | |
2885 int weight0 = h->implicit_weight[refn0][refn1]; | |
2886 int weight1 = 64 - weight0; | |
3316 | 2887 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2888 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2889 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 2890 }else{ |
3316 | 2891 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 2892 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 2893 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 2894 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2895 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 2896 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 2897 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2898 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 2899 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 2900 } |
2901 }else{ | |
2902 int list = list1 ? 1 : 0; | |
2903 int refn = h->ref_cache[list][ scan8[n] ]; | |
2904 Picture *ref= &h->ref_list[list][refn]; | |
2905 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2906 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2907 qpix_put, chroma_put); | |
2908 | |
3316 | 2909 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 2910 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
2911 if(h->use_weight_chroma){ | |
3316 | 2912 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2913 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 2914 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2915 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
2916 } | |
2917 } | |
2918 } | |
2919 | |
2920 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2921 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2922 int x_offset, int y_offset, | |
2923 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2924 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 2925 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 2926 int list0, int list1){ |
2927 if((h->use_weight==2 && list0 && list1 | |
2928 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2929 || h->use_weight==1) | |
2930 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2931 x_offset, y_offset, qpix_put, chroma_put, | |
2932 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2933 else | |
2934 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2935 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2936 } | |
2937 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2938 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
|
2939 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2940 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2941 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2942 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
|
2943 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2944 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
|
2945 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
|
2946 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 2947 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
|
2948 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
|
2949 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
|
2950 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
|
2951 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2952 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2953 |
1168 | 2954 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2955 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2956 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2957 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2958 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
|
2959 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2960 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 2961 |
1168 | 2962 assert(IS_INTER(mb_type)); |
2967 | 2963 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2964 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2965 |
1168 | 2966 if(IS_16X16(mb_type)){ |
2967 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2968 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2969 &weight_op[0], &weight_avg[0], |
1168 | 2970 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2971 }else if(IS_16X8(mb_type)){ | |
2972 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2973 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2974 &weight_op[1], &weight_avg[1], |
1168 | 2975 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2976 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
2977 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2978 &weight_op[1], &weight_avg[1], |
1168 | 2979 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2980 }else if(IS_8X16(mb_type)){ | |
3316 | 2981 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 2982 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2983 &weight_op[2], &weight_avg[2], |
1168 | 2984 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 2985 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 2986 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2987 &weight_op[2], &weight_avg[2], |
1168 | 2988 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2989 }else{ | |
2990 int i; | |
2967 | 2991 |
1168 | 2992 assert(IS_8X8(mb_type)); |
2993 | |
2994 for(i=0; i<4; i++){ | |
2995 const int sub_mb_type= h->sub_mb_type[i]; | |
2996 const int n= 4*i; | |
2997 int x_offset= (i&1)<<2; | |
2998 int y_offset= (i&2)<<1; | |
2999 | |
3000 if(IS_SUB_8X8(sub_mb_type)){ | |
3001 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3002 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 3003 &weight_op[3], &weight_avg[3], |
1168 | 3004 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3005 }else if(IS_SUB_8X4(sub_mb_type)){ | |
3006 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3007 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3008 &weight_op[4], &weight_avg[4], |
1168 | 3009 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3010 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
3011 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3012 &weight_op[4], &weight_avg[4], |
1168 | 3013 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3014 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 3015 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 3016 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3017 &weight_op[5], &weight_avg[5], |
1168 | 3018 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 3019 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 3020 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3021 &weight_op[5], &weight_avg[5], |
1168 | 3022 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3023 }else{ | |
3024 int j; | |
3025 assert(IS_SUB_4X4(sub_mb_type)); | |
3026 for(j=0; j<4; j++){ | |
3027 int sub_x_offset= x_offset + 2*(j&1); | |
3028 int sub_y_offset= y_offset + (j&2); | |
3029 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
3030 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 3031 &weight_op[6], &weight_avg[6], |
1168 | 3032 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3033 } | |
3034 } | |
3035 } | |
3036 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3037 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3038 prefetch_motion(h, 1); |
1168 | 3039 } |
3040 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3041 static void decode_init_vlc(){ |
1168 | 3042 static int done = 0; |
3043 | |
3044 if (!done) { | |
3045 int i; | |
3046 done = 1; | |
3047 | |
2967 | 3048 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 3049 &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
|
3050 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 3051 |
3052 for(i=0; i<4; i++){ | |
2967 | 3053 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 3054 &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
|
3055 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 3056 } |
3057 | |
3058 for(i=0; i<3; i++){ | |
3059 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
3060 &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
|
3061 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3062 } |
3063 for(i=0; i<15; i++){ | |
2967 | 3064 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 3065 &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
|
3066 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3067 } |
3068 | |
3069 for(i=0; i<6; i++){ | |
2967 | 3070 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 3071 &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
|
3072 &run_bits[i][0], 1, 1, 1); |
1168 | 3073 } |
2967 | 3074 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 3075 &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
|
3076 &run_bits[6][0], 1, 1, 1); |
1168 | 3077 } |
3078 } | |
3079 | |
3080 /** | |
3081 * Sets the intra prediction function pointers. | |
3082 */ | |
3083 static void init_pred_ptrs(H264Context *h){ | |
3084 // MpegEncContext * const s = &h->s; | |
3085 | |
3086 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
3087 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
3088 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
3089 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
3090 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
3091 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
3092 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
3093 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
3094 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
3095 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
3096 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
3097 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
3098 | |
2755 | 3099 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
3100 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
3101 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
3102 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
3103 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
3104 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
3105 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
3106 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
3107 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
3108 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
3109 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
3110 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
3111 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3112 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3113 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3114 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3115 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c; |
1168 | 3116 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; |
3117 h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c; | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3118 h->pred8x8[DC_128_PRED8x8 ]= ff_pred8x8_128_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3119 |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3120 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3121 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3122 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3123 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c; |
1168 | 3124 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; |
3125 h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c; | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3126 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c; |
1168 | 3127 } |
3128 | |
3129 static void free_tables(H264Context *h){ | |
3130 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
|
3131 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
|
3132 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
|
3133 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
|
3134 av_freep(&h->mvd_table[1]); |
2396 | 3135 av_freep(&h->direct_table); |
1168 | 3136 av_freep(&h->non_zero_count); |
3137 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
|
3138 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3139 av_freep(&h->top_borders[0]); |
1168 | 3140 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
|
3141 |
1168 | 3142 av_freep(&h->mb2b_xy); |
3143 av_freep(&h->mb2b8_xy); | |
2415 | 3144 |
3145 av_freep(&h->s.obmc_scratchpad); | |
1168 | 3146 } |
3147 | |
2919 | 3148 static void init_dequant8_coeff_table(H264Context *h){ |
3149 int i,q,x; | |
3174 | 3150 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 3151 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
3152 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
3153 | |
3154 for(i=0; i<2; i++ ){ | |
3155 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
3156 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
3157 break; | |
3158 } | |
3159 | |
3160 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3161 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3162 int idx = ff_rem6[q]; |
2919 | 3163 for(x=0; x<64; x++) |
3174 | 3164 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
3165 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
3166 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 3167 } |
3168 } | |
3169 } | |
3170 | |
3171 static void init_dequant4_coeff_table(H264Context *h){ | |
3172 int i,j,q,x; | |
3005 | 3173 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 3174 for(i=0; i<6; i++ ){ |
3175 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
3176 for(j=0; j<i; j++){ | |
3177 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
3178 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
3179 break; | |
3180 } | |
3181 } | |
3182 if(j<i) | |
3183 continue; | |
3184 | |
3185 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3186 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3187 int idx = ff_rem6[q]; |
2919 | 3188 for(x=0; x<16; x++) |
3005 | 3189 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
3190 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 3191 h->pps.scaling_matrix4[i][x]) << shift; |
3192 } | |
3193 } | |
3194 } | |
3195 | |
3196 static void init_dequant_tables(H264Context *h){ | |
3197 int i,x; | |
3198 init_dequant4_coeff_table(h); | |
3199 if(h->pps.transform_8x8_mode) | |
3200 init_dequant8_coeff_table(h); | |
3201 if(h->sps.transform_bypass){ | |
3202 for(i=0; i<6; i++) | |
3203 for(x=0; x<16; x++) | |
3204 h->dequant4_coeff[i][0][x] = 1<<6; | |
3205 if(h->pps.transform_8x8_mode) | |
3206 for(i=0; i<2; i++) | |
3207 for(x=0; x<64; x++) | |
3208 h->dequant8_coeff[i][0][x] = 1<<6; | |
3209 } | |
3210 } | |
3211 | |
3212 | |
1168 | 3213 /** |
3214 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3215 * needs width/height |
1168 | 3216 */ |
3217 static int alloc_tables(H264Context *h){ | |
3218 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
|
3219 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 3220 int x,y; |
1168 | 3221 |
3222 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
|
3223 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3224 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 3225 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
|
3226 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
|
3227 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 3228 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 3229 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3230 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
|
3231 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
|
3232 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
|
3233 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 3234 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
|
3235 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3236 |
3316 | 3237 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
3238 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 3239 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
3240 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
|
3241 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 3242 for(y=0; y<s->mb_height; y++){ |
3243 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
|
3244 const int mb_xy= x + y*s->mb_stride; |
1168 | 3245 const int b_xy = 4*x + 4*y*h->b_stride; |
3246 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 3247 |
1168 | 3248 h->mb2b_xy [mb_xy]= b_xy; |
3249 h->mb2b8_xy[mb_xy]= b8_xy; | |
3250 } | |
3251 } | |
2415 | 3252 |
2417 | 3253 s->obmc_scratchpad = NULL; |
3254 | |
2920 | 3255 if(!h->dequant4_coeff[0]) |
3256 init_dequant_tables(h); | |
3257 | |
1168 | 3258 return 0; |
3259 fail: | |
3260 free_tables(h); | |
3261 return -1; | |
3262 } | |
3263 | |
3264 static void common_init(H264Context *h){ | |
3265 MpegEncContext * const s = &h->s; | |
3266 | |
3267 s->width = s->avctx->width; | |
3268 s->height = s->avctx->height; | |
3269 s->codec_id= s->avctx->codec->id; | |
2967 | 3270 |
1168 | 3271 init_pred_ptrs(h); |
3272 | |
2919 | 3273 h->dequant_coeff_pps= -1; |
1698 | 3274 s->unrestricted_mv=1; |
1168 | 3275 s->decode=1; //FIXME |
2920 | 3276 |
3277 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
3278 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 3279 } |
3280 | |
3281 static int decode_init(AVCodecContext *avctx){ | |
3282 H264Context *h= avctx->priv_data; | |
3283 MpegEncContext * const s = &h->s; | |
3284 | |
1892 | 3285 MPV_decode_defaults(s); |
2967 | 3286 |
1168 | 3287 s->avctx = avctx; |
3288 common_init(h); | |
3289 | |
3290 s->out_format = FMT_H264; | |
3291 s->workaround_bugs= avctx->workaround_bugs; | |
3292 | |
3293 // set defaults | |
3294 // s->decode_mb= ff_h263_decode_mb; | |
3295 s->low_delay= 1; | |
3296 avctx->pix_fmt= PIX_FMT_YUV420P; | |
3297 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3298 decode_init_vlc(); |
2967 | 3299 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3300 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
|
3301 *(char *)avctx->extradata == 1){ |
2227 | 3302 h->is_avc = 1; |
3303 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
|
3304 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3305 h->is_avc = 0; |
2227 | 3306 } |
3307 | |
1168 | 3308 return 0; |
3309 } | |
3310 | |
2935 | 3311 static int frame_start(H264Context *h){ |
1168 | 3312 MpegEncContext * const s = &h->s; |
3313 int i; | |
3314 | |
2935 | 3315 if(MPV_frame_start(s, s->avctx) < 0) |
3316 return -1; | |
1168 | 3317 ff_er_frame_start(s); |
3318 | |
3319 assert(s->linesize && s->uvlinesize); | |
3320 | |
3321 for(i=0; i<16; i++){ | |
3322 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
|
3323 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 3324 } |
3325 for(i=0; i<4; i++){ | |
3326 h->block_offset[16+i]= | |
3327 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
|
3328 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3329 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 3330 } |
3331 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
3332 /* 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
|
3333 * 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
|
3334 if(!s->obmc_scratchpad) |
3316 | 3335 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
3336 | |
3337 /* some macroblocks will be accessed before they're available */ | |
3338 if(FRAME_MBAFF) | |
3339 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
|
3340 |
1168 | 3341 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 3342 return 0; |
1168 | 3343 } |
3344 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3345 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
|
3346 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
|
3347 int i; |
2967 | 3348 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3349 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
|
3350 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
|
3351 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
|
3352 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3353 // 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
|
3354 // 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
|
3355 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
|
3356 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
|
3357 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
|
3358 } |
2967 | 3359 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3360 *(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3361 *(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
|
3362 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3363 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
|
3364 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
|
3365 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
|
3366 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
|
3367 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
|
3368 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
|
3369 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3370 *(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3371 *(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
|
3372 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3373 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3374 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3375 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
|
3376 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
|
3377 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
|
3378 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3379 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
|
3380 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
|
3381 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3382 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
|
3383 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
|
3384 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
|
3385 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3386 #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
|
3387 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3388 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3389 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3390 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3391 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3392 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3393 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
|
3394 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
|
3395 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3396 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3397 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3398 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3399 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3400 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3401 if(s->mb_x+1 < s->mb_width){ |
2755 | 3402 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3403 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3404 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3405 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3406 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
|
3407 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3408 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
|
3409 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
|
3410 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
|
3411 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3412 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3413 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3414 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3415 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
|
3416 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3417 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3418 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3419 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3420 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
|
3421 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3422 int i; |
2967 | 3423 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3424 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3425 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3426 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3427 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3428 // 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
|
3429 // 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
|
3430 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
|
3431 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
|
3432 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3433 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
|
3434 } |
2967 | 3435 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3436 *(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3437 *(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
|
3438 *(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
|
3439 *(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
|
3440 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3441 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3442 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
|
3443 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
|
3444 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
|
3445 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
|
3446 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3447 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
|
3448 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
|
3449 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3450 *(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3451 *(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
|
3452 *(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
|
3453 *(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
|
3454 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3455 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3456 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3457 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
|
3458 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3459 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3460 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3461 int deblock_left = (s->mb_x > 0); |
3316 | 3462 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
|
3463 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3464 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
|
3465 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3466 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3467 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3468 src_cr -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3469 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3470 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3471 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3472 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3473 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3474 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3475 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3476 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3477 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
|
3478 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
|
3479 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3480 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3481 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3482 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3483 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3484 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
|
3485 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
|
3486 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3487 if(s->mb_x+1 < s->mb_width){ |
3488 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3489 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3490 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3491 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3492 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3493 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3494 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3495 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
|
3496 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
|
3497 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
|
3498 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3499 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3500 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3501 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+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
|
3502 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
|
3503 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
|
3504 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
|
3505 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3506 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3507 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3508 |
1168 | 3509 static void hl_decode_mb(H264Context *h){ |
3510 MpegEncContext * const s = &h->s; | |
3511 const int mb_x= s->mb_x; | |
3512 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
|
3513 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3514 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3515 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3516 int linesize, uvlinesize /*dct_offset*/; | |
3517 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3518 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
|
3519 const unsigned int bottom = mb_y & 1; |
2763 | 3520 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass); |
3521 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
|
3522 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3523 |
3524 if(!s->decode) | |
3525 return; | |
3526 | |
3527 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3528 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3529 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3530 | |
4000 | 3531 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3532 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3533 | |
3316 | 3534 if (MB_FIELD) { |
3535 linesize = h->mb_linesize = s->linesize * 2; | |
3536 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
|
3537 block_offset = &h->block_offset[24]; |
1168 | 3538 if(mb_y&1){ //FIXME move out of this func? |
3539 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3540 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3541 dest_cr-= s->uvlinesize*7; |
1168 | 3542 } |
3316 | 3543 if(FRAME_MBAFF) { |
3544 int list; | |
3545 for(list=0; list<2; list++){ | |
3546 if(!USES_LIST(mb_type, list)) | |
3547 continue; | |
3548 if(IS_16X16(mb_type)){ | |
3549 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3550 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3551 }else{ | |
3552 for(i=0; i<16; i+=4){ | |
3553 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3554 int ref = h->ref_cache[list][scan8[i]]; | |
3555 if(ref >= 0) | |
3556 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3557 } | |
3558 } | |
3559 } | |
3560 } | |
1168 | 3561 } else { |
3316 | 3562 linesize = h->mb_linesize = s->linesize; |
3563 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3564 // dct_offset = s->linesize * 16; |
3565 } | |
2967 | 3566 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3567 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3568 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3569 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
|
3570 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3571 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3572 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3573 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3574 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3575 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3576 } |
1168 | 3577 |
3316 | 3578 if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3579 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ | |
3580 int mbt_y = mb_y&~1; | |
3581 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3582 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3583 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3584 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3585 } | |
3586 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3587 if (IS_INTRA_PCM(mb_type)) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3588 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3589 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3590 // 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
|
3591 // 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
|
3592 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3593 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3594 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
|
3595 *(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
|
3596 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3597 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3598 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3599 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3600 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3601 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
|
3602 *(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
|
3603 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3604 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3605 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3606 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3607 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3608 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
|
3609 *(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
|
3610 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3611 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3612 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3613 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3614 if(IS_INTRA(mb_type)){ |
3316 | 3615 if(h->deblocking_filter && !FRAME_MBAFF) |
3616 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
|
3617 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3618 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
|
3619 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
|
3620 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
|
3621 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3622 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3623 if(IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3624 if(!s->encoding){ |
2755 | 3625 if(IS_8x8DCT(mb_type)){ |
3626 for(i=0; i<16; i+=4){ | |
3627 uint8_t * const ptr= dest_y + block_offset[i]; | |
3628 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
|
3629 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3630 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
3631 (h->topright_samples_available<<(i+1))&0x8000, linesize); | |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3632 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3633 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3634 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3635 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3636 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3637 } |
2755 | 3638 } |
3639 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3640 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
|
3641 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
|
3642 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3643 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
|
3644 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3645 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3646 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
|
3647 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
|
3648 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
|
3649 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3650 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3651 topright= (uint8_t*) &tr; |
2967 | 3652 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3653 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3654 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3655 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3656 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3657 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3658 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3659 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3660 if(s->codec_id == CODEC_ID_H264){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3661 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3662 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3663 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3664 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3665 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3666 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
|
3667 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3668 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3669 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3670 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3671 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
2763 | 3672 if(s->codec_id == CODEC_ID_H264){ |
3673 if(!transform_bypass) | |
2919 | 3674 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3675 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3676 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
|
3677 } |
3316 | 3678 if(h->deblocking_filter && !FRAME_MBAFF) |
3679 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
|
3680 }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
|
3681 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
|
3682 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
|
3683 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
|
3684 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
|
3685 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3686 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3687 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3688 if(!IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3689 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3690 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3691 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3692 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3693 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3694 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3695 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
|
3696 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3697 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3698 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3699 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3700 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3701 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3702 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3703 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
|
3704 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3705 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
|
3706 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3707 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3708 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3709 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3710 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
|
3711 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
|
3712 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
|
3713 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3714 } |
1168 | 3715 } |
3716 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3717 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3718 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3719 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3720 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3721 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3722 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3723 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3724 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3725 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3726 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]); |
3727 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 | 3728 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3729 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3730 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3731 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3732 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
|
3733 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3734 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
|
3735 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3736 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3737 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
|
3738 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
|
3739 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
|
3740 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
|
3741 } |
1250 | 3742 } |
1168 | 3743 } |
3744 } | |
3745 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3746 if(h->deblocking_filter) { |
3316 | 3747 if (FRAME_MBAFF) { |
3748 //FIXME try deblocking one mb at a time? | |
3749 // 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
|
3750 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
|
3751 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
|
3752 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
|
3753 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
|
3754 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
|
3755 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3756 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
|
3757 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
|
3758 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
|
3759 |
3316 | 3760 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3761 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3762 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3763 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3764 // deblock a pair |
2967 | 3765 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3766 s->mb_y--; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3767 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
|
3768 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3769 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
|
3770 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
|
3771 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3772 s->mb_y++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3773 tprintf("call mbaff filter_mb\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3774 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3775 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
|
3776 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
|
3777 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3778 tprintf("call filter_mb\n"); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3779 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
|
3780 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
|
3781 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
|
3782 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3783 } |
1168 | 3784 } |
3785 | |
3786 /** | |
3787 * fills the default_ref_list. | |
3788 */ | |
3789 static int fill_default_ref_list(H264Context *h){ | |
3790 MpegEncContext * const s = &h->s; | |
3791 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
|
3792 int smallest_poc_greater_than_current = -1; |
2582 | 3793 Picture sorted_short_ref[32]; |
2967 | 3794 |
1168 | 3795 if(h->slice_type==B_TYPE){ |
3796 int out_i; | |
2713 | 3797 int limit= INT_MIN; |
1168 | 3798 |
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
|
3799 /* sort frame according to poc in B slice */ |
1168 | 3800 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3801 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
|
3802 int best_poc=INT_MAX; |
1168 | 3803 |
3804 for(i=0; i<h->short_ref_count; i++){ | |
3805 const int poc= h->short_ref[i]->poc; | |
3806 if(poc > limit && poc < best_poc){ | |
3807 best_poc= poc; | |
3808 best_i= i; | |
3809 } | |
3810 } | |
2967 | 3811 |
2713 | 3812 assert(best_i != INT_MIN); |
2967 | 3813 |
1168 | 3814 limit= best_poc; |
3815 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
|
3816 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
|
3817 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
|
3818 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
|
3819 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
|
3820 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3821 } |
1168 | 3822 } |
3823 } | |
3824 | |
3825 if(s->picture_structure == PICT_FRAME){ | |
3826 if(h->slice_type==B_TYPE){ | |
3827 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
|
3828 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
|
3829 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3830 // find the largest poc |
1168 | 3831 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
|
3832 int index = 0; |
2447 | 3833 int j= -99; |
3834 int step= list ? -1 : 1; | |
3835 | |
3836 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3837 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
|
3838 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3839 return -1; |
2447 | 3840 step = -step; |
3841 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
|
3842 } |
2447 | 3843 if(sorted_short_ref[j].reference != 3) continue; |
3844 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3845 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3846 } |
3847 | |
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
|
3848 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
|
3849 if(h->long_ref[i] == NULL) continue; |
1168 | 3850 if(h->long_ref[i]->reference != 3) continue; |
3851 | |
3852 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3853 h->default_ref_list[ list ][index++].pic_id= i;; | |
3854 } | |
2967 | 3855 |
2447 | 3856 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
|
3857 // 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
|
3858 // L0 and L1 are identical |
1168 | 3859 Picture temp= h->default_ref_list[1][0]; |
3860 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3861 h->default_ref_list[1][1] = temp; |
1168 | 3862 } |
3863 | |
3864 if(index < h->ref_count[ list ]) | |
3865 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3866 } | |
3867 }else{ | |
3868 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3869 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3870 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3871 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3872 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3873 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3874 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
|
3875 if(h->long_ref[i] == NULL) continue; |
1168 | 3876 if(h->long_ref[i]->reference != 3) continue; |
3877 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3878 h->default_ref_list[0][index++].pic_id= i;; | |
3879 } | |
3880 if(index < h->ref_count[0]) | |
3881 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3882 } | |
3883 }else{ //FIELD | |
3884 if(h->slice_type==B_TYPE){ | |
3885 }else{ | |
3886 //FIXME second field balh | |
3887 } | |
3888 } | |
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
|
3889 #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
|
3890 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
|
3891 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
|
3892 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3893 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
|
3894 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
|
3895 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
|
3896 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3897 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3898 #endif |
1168 | 3899 return 0; |
3900 } | |
3901 | |
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
|
3902 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
|
3903 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
|
3904 |
1168 | 3905 static int decode_ref_pic_list_reordering(H264Context *h){ |
3906 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3907 int list, index; |
2967 | 3908 |
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
|
3909 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
|
3910 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3911 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 3912 |
1168 | 3913 for(list=0; list<2; list++){ |
3914 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); | |
3915 | |
3916 if(get_bits1(&s->gb)){ | |
3917 int pred= h->curr_pic_num; | |
3918 | |
3919 for(index=0; ; index++){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3920 unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3921 unsigned int pic_id; |
1168 | 3922 int i; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3923 Picture *ref = NULL; |
2967 | 3924 |
3925 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
|
3926 break; |
2967 | 3927 |
1168 | 3928 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3929 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3930 return -1; |
3931 } | |
2967 | 3932 |
1168 | 3933 if(reordering_of_pic_nums_idc<3){ |
3934 if(reordering_of_pic_nums_idc<2){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3935 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; |
1168 | 3936 |
3937 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
|
3938 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3939 return -1; |
3940 } | |
3941 | |
3942 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3943 else pred+= abs_diff_pic_num; | |
3944 pred &= h->max_pic_num - 1; | |
2967 | 3945 |
2683 | 3946 for(i= h->short_ref_count-1; i>=0; i--){ |
3947 ref = h->short_ref[i]; | |
3948 assert(ref->reference == 3); | |
3949 assert(!ref->long_ref); | |
3950 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 3951 break; |
3952 } | |
2683 | 3953 if(i>=0) |
3954 ref->pic_id= ref->frame_num; | |
1168 | 3955 }else{ |
3956 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3957 if(pic_id>31){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3958 av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3959 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3960 } |
2683 | 3961 ref = h->long_ref[pic_id]; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3962 if(ref){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3963 ref->pic_id= pic_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3964 assert(ref->reference == 3); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3965 assert(ref->long_ref); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3966 i=0; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3967 }else{ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3968 i=-1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3969 } |
1168 | 3970 } |
3971 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3972 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3973 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3974 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 3975 } else { |
3976 for(i=index; i+1<h->ref_count[list]; i++){ | |
3977 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
3978 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
|
3979 } |
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
|
3980 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
|
3981 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
|
3982 } |
2683 | 3983 h->ref_list[list][index]= *ref; |
1168 | 3984 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3985 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3986 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3987 return -1; |
3988 } | |
3989 } | |
3990 } | |
3991 | |
3992 if(h->slice_type!=B_TYPE) break; | |
3993 } | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3994 for(list=0; list<2; list++){ |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3995 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
|
3996 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3997 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3998 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3999 if(h->slice_type!=B_TYPE) break; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4000 } |
2967 | 4001 |
2396 | 4002 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
4003 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
4004 direct_ref_list_init(h); |
2967 | 4005 return 0; |
1168 | 4006 } |
4007 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
4008 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 4009 int list, i, j; |
4010 for(list=0; list<2; list++){ | |
4011 for(i=0; i<h->ref_count[list]; i++){ | |
4012 Picture *frame = &h->ref_list[list][i]; | |
4013 Picture *field = &h->ref_list[list][16+2*i]; | |
4014 field[0] = *frame; | |
4015 for(j=0; j<3; j++) | |
4016 field[0].linesize[j] <<= 1; | |
4017 field[1] = field[0]; | |
4018 for(j=0; j<3; j++) | |
4019 field[1].data[j] += frame->linesize[j]; | |
4020 | |
4021 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4022 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4023 for(j=0; j<2; j++){ | |
4024 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4025 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4026 } | |
4027 } | |
4028 } | |
4029 for(j=0; j<h->ref_count[1]; j++){ | |
4030 for(i=0; i<h->ref_count[0]; i++) | |
4031 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4032 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4033 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4034 } | |
4035 } | |
4036 | |
1168 | 4037 static int pred_weight_table(H264Context *h){ |
4038 MpegEncContext * const s = &h->s; | |
4039 int list, i; | |
2415 | 4040 int luma_def, chroma_def; |
2967 | 4041 |
2415 | 4042 h->use_weight= 0; |
4043 h->use_weight_chroma= 0; | |
1168 | 4044 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4045 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4046 luma_def = 1<<h->luma_log2_weight_denom; |
4047 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4048 |
4049 for(list=0; list<2; list++){ | |
4050 for(i=0; i<h->ref_count[list]; i++){ | |
4051 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4052 |
1168 | 4053 luma_weight_flag= get_bits1(&s->gb); |
4054 if(luma_weight_flag){ | |
4055 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4056 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4057 if( h->luma_weight[list][i] != luma_def |
4058 || h->luma_offset[list][i] != 0) | |
4059 h->use_weight= 1; | |
4060 }else{ | |
4061 h->luma_weight[list][i]= luma_def; | |
4062 h->luma_offset[list][i]= 0; | |
1168 | 4063 } |
4064 | |
4065 chroma_weight_flag= get_bits1(&s->gb); | |
4066 if(chroma_weight_flag){ | |
4067 int j; | |
4068 for(j=0; j<2; j++){ | |
4069 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4070 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4071 if( h->chroma_weight[list][i][j] != chroma_def |
4072 || h->chroma_offset[list][i][j] != 0) | |
4073 h->use_weight_chroma= 1; | |
4074 } | |
4075 }else{ | |
4076 int j; | |
4077 for(j=0; j<2; j++){ | |
4078 h->chroma_weight[list][i][j]= chroma_def; | |
4079 h->chroma_offset[list][i][j]= 0; | |
1168 | 4080 } |
4081 } | |
4082 } | |
4083 if(h->slice_type != B_TYPE) break; | |
4084 } | |
2415 | 4085 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4086 return 0; |
4087 } | |
4088 | |
2415 | 4089 static void implicit_weight_table(H264Context *h){ |
4090 MpegEncContext * const s = &h->s; | |
4091 int ref0, ref1; | |
4092 int cur_poc = s->current_picture_ptr->poc; | |
4093 | |
4094 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4095 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4096 h->use_weight= 0; | |
4097 h->use_weight_chroma= 0; | |
4098 return; | |
4099 } | |
4100 | |
4101 h->use_weight= 2; | |
4102 h->use_weight_chroma= 2; | |
4103 h->luma_log2_weight_denom= 5; | |
4104 h->chroma_log2_weight_denom= 5; | |
4105 | |
4106 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4107 int poc0 = h->ref_list[0][ref0].poc; | |
4108 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4109 int poc1 = h->ref_list[1][ref1].poc; |
2415 | 4110 int td = clip(poc1 - poc0, -128, 127); |
4111 if(td){ | |
4112 int tb = clip(cur_poc - poc0, -128, 127); | |
4001 | 4113 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2415 | 4114 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
4115 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
4116 h->implicit_weight[ref0][ref1] = 32; | |
4117 else | |
4118 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4119 }else | |
4120 h->implicit_weight[ref0][ref1] = 32; | |
4121 } | |
4122 } | |
4123 } | |
4124 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4125 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
|
4126 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4127 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4128 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
|
4129 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4130 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4131 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
|
4132 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
|
4133 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4134 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4135 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4136 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4137 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4138 |
1168 | 4139 /** |
2392 | 4140 * instantaneous decoder refresh. |
1168 | 4141 */ |
4142 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
|
4143 int i; |
1168 | 4144 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4145 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4146 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
|
4147 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
|
4148 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4149 } |
1168 | 4150 } |
4151 h->long_ref_count=0; | |
4152 | |
4153 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
|
4154 unreference_pic(h, h->short_ref[i]); |
1168 | 4155 h->short_ref[i]= NULL; |
4156 } | |
4157 h->short_ref_count=0; | |
4158 } | |
4159 | |
2640 | 4160 /* forget old pics after a seek */ |
4161 static void flush_dpb(AVCodecContext *avctx){ | |
4162 H264Context *h= avctx->priv_data; | |
4163 int i; | |
3144 | 4164 for(i=0; i<16; i++) { |
4165 if(h->delayed_pic[i]) | |
4166 h->delayed_pic[i]->reference= 0; | |
2640 | 4167 h->delayed_pic[i]= NULL; |
3144 | 4168 } |
4169 if(h->delayed_output_pic) | |
4170 h->delayed_output_pic->reference= 0; | |
2640 | 4171 h->delayed_output_pic= NULL; |
4172 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4173 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4174 h->s.current_picture_ptr->reference= 0; |
2640 | 4175 } |
4176 | |
1168 | 4177 /** |
4178 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4179 * @return the removed picture or NULL if an error occurs |
1168 | 4180 */ |
4181 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4182 MpegEncContext * const s = &h->s; |
1168 | 4183 int i; |
2967 | 4184 |
1169 | 4185 if(s->avctx->debug&FF_DEBUG_MMCO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4186 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4187 |
1168 | 4188 for(i=0; i<h->short_ref_count; i++){ |
4189 Picture *pic= h->short_ref[i]; | |
1169 | 4190 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
|
4191 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4192 if(pic->frame_num == frame_num){ |
4193 h->short_ref[i]= NULL; | |
4194 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4195 h->short_ref_count--; | |
4196 return pic; | |
4197 } | |
4198 } | |
4199 return NULL; | |
4200 } | |
4201 | |
4202 /** | |
4203 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4204 * @return the removed picture or NULL if an error occurs |
1168 | 4205 */ |
4206 static Picture * remove_long(H264Context *h, int i){ | |
4207 Picture *pic; | |
4208 | |
4209 pic= h->long_ref[i]; | |
4210 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
|
4211 if(pic) h->long_ref_count--; |
1168 | 4212 |
4213 return pic; | |
4214 } | |
4215 | |
4216 /** | |
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
|
4217 * 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
|
4218 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4219 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
|
4220 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
|
4221 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
|
4222 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
|
4223 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
|
4224 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
|
4225 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
|
4226 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4227 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4228 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4229 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4230 /** |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4231 * 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
|
4232 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4233 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
|
4234 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
|
4235 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
|
4236 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
|
4237 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
|
4238 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
|
4239 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
|
4240 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4241 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4242 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4243 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4244 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4245 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4246 /** |
1168 | 4247 * Executes the reference picture marking (memory management control operations). |
4248 */ | |
4249 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4250 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
|
4251 int i, j; |
1168 | 4252 int current_is_long=0; |
4253 Picture *pic; | |
2967 | 4254 |
1168 | 4255 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
|
4256 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4257 |
1168 | 4258 for(i=0; i<mmco_count; i++){ |
4259 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
|
4260 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 | 4261 |
4262 switch(mmco[i].opcode){ | |
4263 case MMCO_SHORT2UNUSED: | |
4264 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
|
4265 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4266 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4267 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
|
4268 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4269 break; |
4270 case MMCO_SHORT2LONG: | |
4271 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
|
4272 if(pic) unreference_pic(h, pic); |
2967 | 4273 |
1168 | 4274 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4275 if (h->long_ref[ mmco[i].long_index ]){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4276 h->long_ref[ mmco[i].long_index ]->long_ref=1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4277 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4278 } |
1168 | 4279 break; |
4280 case MMCO_LONG2UNUSED: | |
4281 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
|
4282 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4283 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4284 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
|
4285 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4286 break; |
4287 case MMCO_LONG: | |
4288 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
|
4289 if(pic) unreference_pic(h, pic); |
2967 | 4290 |
1168 | 4291 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4292 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4293 h->long_ref_count++; | |
2967 | 4294 |
1168 | 4295 current_is_long=1; |
4296 break; | |
4297 case MMCO_SET_MAX_LONG: | |
4298 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
|
4299 // 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
|
4300 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
|
4301 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
|
4302 if (pic) unreference_pic(h, pic); |
1168 | 4303 } |
4304 break; | |
4305 case MMCO_RESET: | |
4306 while(h->short_ref_count){ | |
4307 pic= remove_short(h, h->short_ref[0]->frame_num); | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4308 if(pic) unreference_pic(h, pic); |
1168 | 4309 } |
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
|
4310 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
|
4311 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
|
4312 if(pic) unreference_pic(h, pic); |
1168 | 4313 } |
4314 break; | |
4315 default: assert(0); | |
4316 } | |
4317 } | |
2967 | 4318 |
1168 | 4319 if(!current_is_long){ |
4320 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4321 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4322 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4323 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4324 } |
2967 | 4325 |
1168 | 4326 if(h->short_ref_count) |
1169 | 4327 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4328 | |
4329 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4330 h->short_ref[0]->long_ref=0; |
4331 h->short_ref_count++; | |
4332 } | |
2967 | 4333 |
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
|
4334 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
|
4335 print_long_term(h); |
2967 | 4336 return 0; |
1168 | 4337 } |
4338 | |
4339 static int decode_ref_pic_marking(H264Context *h){ | |
4340 MpegEncContext * const s = &h->s; | |
4341 int i; | |
2967 | 4342 |
1168 | 4343 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4344 s->broken_link= get_bits1(&s->gb) -1; | |
4345 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4346 if(h->mmco[0].long_index == -1) | |
4347 h->mmco_index= 0; | |
4348 else{ | |
4349 h->mmco[0].opcode= MMCO_LONG; | |
4350 h->mmco_index= 1; | |
2967 | 4351 } |
1168 | 4352 }else{ |
4353 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4354 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4355 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4356 | |
4357 h->mmco[i].opcode= opcode; | |
4358 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4359 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 | |
4360 /* 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
|
4361 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4362 return -1; |
4363 }*/ | |
4364 } | |
4365 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4366 unsigned int long_index= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4367 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ long_index >= 16){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4368 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4369 return -1; |
4370 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4371 h->mmco[i].long_index= long_index; |
1168 | 4372 } |
2967 | 4373 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4374 if(opcode > (unsigned)MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4375 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4376 return -1; |
4377 } | |
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
|
4378 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
|
4379 break; |
1168 | 4380 } |
4381 h->mmco_index= i; | |
4382 }else{ | |
4383 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4384 | |
4385 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4386 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4387 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4388 h->mmco_index= 1; | |
4389 }else | |
4390 h->mmco_index= 0; | |
4391 } | |
4392 } | |
2967 | 4393 |
4394 return 0; | |
1168 | 4395 } |
4396 | |
4397 static int init_poc(H264Context *h){ | |
4398 MpegEncContext * const s = &h->s; | |
4399 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4400 int field_poc[2]; | |
4401 | |
4402 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4403 h->frame_num_offset= 0; | |
4404 }else{ | |
4405 if(h->frame_num < h->prev_frame_num) | |
4406 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4407 else | |
4408 h->frame_num_offset= h->prev_frame_num_offset; | |
4409 } | |
4410 | |
4411 if(h->sps.poc_type==0){ | |
4412 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4413 | |
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
|
4414 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
|
4415 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
|
4416 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
|
4417 } |
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
|
4418 |
1168 | 4419 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4420 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4421 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4422 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4423 else | |
4424 h->poc_msb = h->prev_poc_msb; | |
4425 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4426 field_poc[0] = |
1168 | 4427 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4428 if(s->picture_structure == PICT_FRAME) |
1168 | 4429 field_poc[1] += h->delta_poc_bottom; |
4430 }else if(h->sps.poc_type==1){ | |
4431 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4432 int i; | |
4433 | |
4434 if(h->sps.poc_cycle_length != 0) | |
4435 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4436 else | |
4437 abs_frame_num = 0; | |
4438 | |
4439 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4440 abs_frame_num--; | |
2967 | 4441 |
1168 | 4442 expected_delta_per_poc_cycle = 0; |
4443 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4444 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4445 | |
4446 if(abs_frame_num > 0){ | |
4447 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4448 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4449 | |
4450 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4451 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4452 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4453 } else | |
4454 expectedpoc = 0; | |
4455 | |
2967 | 4456 if(h->nal_ref_idc == 0) |
1168 | 4457 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4458 |
1168 | 4459 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4460 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4461 | |
4462 if(s->picture_structure == PICT_FRAME) | |
4463 field_poc[1] += h->delta_poc[1]; | |
4464 }else{ | |
4465 int poc; | |
4466 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4467 poc= 0; | |
4468 }else{ | |
4469 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4470 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4471 } | |
4472 field_poc[0]= poc; | |
4473 field_poc[1]= poc; | |
4474 } | |
2967 | 4475 |
1168 | 4476 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4477 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4478 if(s->picture_structure != PICT_TOP_FIELD) | |
4479 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4480 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4481 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4482 | |
4483 return 0; | |
4484 } | |
4485 | |
4486 /** | |
4487 * decodes a slice header. | |
4488 * this will allso call MPV_common_init() and frame_start() as needed | |
4489 */ | |
4490 static int decode_slice_header(H264Context *h){ | |
4491 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4492 unsigned int first_mb_in_slice; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4493 unsigned int pps_id; |
1168 | 4494 int num_ref_idx_active_override_flag; |
4495 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4496 unsigned int slice_type, tmp; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4497 int default_ref_list_done = 0; |
1168 | 4498 |
4499 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
|
4500 s->dropable= h->nal_ref_idc == 0; |
1168 | 4501 |
4502 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4503 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4504 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
|
4505 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4506 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 | 4507 return -1; |
1168 | 4508 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4509 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4510 slice_type -= 5; |
1168 | 4511 h->slice_type_fixed=1; |
4512 }else | |
4513 h->slice_type_fixed=0; | |
2967 | 4514 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4515 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
|
4516 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
|
4517 || (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
|
4518 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
|
4519 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4520 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
|
4521 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4522 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4523 |
1168 | 4524 pps_id= get_ue_golomb(&s->gb); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4525 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4526 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4527 return -1; |
4528 } | |
4529 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4530 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
|
4531 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4532 return -1; |
4533 } | |
4534 | |
1168 | 4535 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4536 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
|
4537 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4538 return -1; |
4539 } | |
2919 | 4540 |
4363 | 4541 if(h->dequant_coeff_pps != pps_id){ |
4542 h->dequant_coeff_pps = pps_id; | |
2919 | 4543 init_dequant_tables(h); |
4544 } | |
2967 | 4545 |
1168 | 4546 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
|
4547 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4548 |
3178 | 4549 h->b_stride= s->mb_width*4; |
4550 h->b8_stride= s->mb_width*2; | |
1168 | 4551 |
1371 | 4552 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4553 if(h->sps.frame_mbs_only_flag) |
1371 | 4554 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4555 else |
1371 | 4556 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4557 |
4558 if (s->context_initialized | |
1548 | 4559 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4560 free_tables(h); |
4561 MPV_common_end(s); | |
4562 } | |
4563 if (!s->context_initialized) { | |
4564 if (MPV_common_init(s) < 0) | |
4565 return -1; | |
2967 | 4566 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4567 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
|
4568 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
|
4569 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
|
4570 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4571 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4572 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4573 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4574 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4575 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4576 #undef T |
4577 } | |
4578 } | |
4579 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4580 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4581 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4582 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4583 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4584 }else{ |
4585 int i; | |
4586 for(i=0; i<64; i++){ | |
4587 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4588 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4589 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4590 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4591 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4592 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4593 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4594 } |
2763 | 4595 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4596 h->zigzag_scan_q0 = zigzag_scan; |
4597 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4598 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4599 h->field_scan_q0 = field_scan; |
4600 h->field_scan8x8_q0 = field_scan8x8; | |
4601 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4602 }else{ |
3316 | 4603 h->zigzag_scan_q0 = h->zigzag_scan; |
4604 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4605 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4606 h->field_scan_q0 = h->field_scan; |
4607 h->field_scan8x8_q0 = h->field_scan8x8; | |
4608 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4609 } |
1168 | 4610 |
4611 alloc_tables(h); | |
4612 | |
4613 s->avctx->width = s->width; | |
4614 s->avctx->height = s->height; | |
1548 | 4615 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4616 if(!s->avctx->sample_aspect_ratio.den) |
4617 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
|
4618 |
2648 | 4619 if(h->sps.timing_info_present_flag){ |
3052 | 4620 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
|
4621 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
|
4622 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4623 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
|
4624 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
|
4625 } |
1168 | 4626 } |
4627 | |
2392 | 4628 if(h->slice_num == 0){ |
2935 | 4629 if(frame_start(h) < 0) |
4630 return -1; | |
1168 | 4631 } |
4632 | |
1169 | 4633 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4634 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4635 | |
3316 | 4636 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4637 h->mb_aff_frame = 0; |
1168 | 4638 if(h->sps.frame_mbs_only_flag){ |
4639 s->picture_structure= PICT_FRAME; | |
4640 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4641 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4642 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4643 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
|
4644 } else { |
1168 | 4645 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4646 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
|
4647 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4648 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4649 assert(s->mb_num == s->mb_width * s->mb_height); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4650 if(first_mb_in_slice << h->mb_aff_frame >= s->mb_num || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4651 first_mb_in_slice >= s->mb_num){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4652 av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4653 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4654 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4655 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4656 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4657 assert(s->mb_y < s->mb_height); |
2967 | 4658 |
1168 | 4659 if(s->picture_structure==PICT_FRAME){ |
4660 h->curr_pic_num= h->frame_num; | |
4661 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4662 }else{ | |
4663 h->curr_pic_num= 2*h->frame_num; | |
4664 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4665 } | |
2967 | 4666 |
1168 | 4667 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4668 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4669 } |
2967 | 4670 |
1168 | 4671 if(h->sps.poc_type==0){ |
4672 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4673 |
1168 | 4674 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4675 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4676 } | |
4677 } | |
2967 | 4678 |
1168 | 4679 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4680 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4681 |
1168 | 4682 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4683 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4684 } | |
2967 | 4685 |
1168 | 4686 init_poc(h); |
2967 | 4687 |
1168 | 4688 if(h->pps.redundant_pic_cnt_present){ |
4689 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4690 } | |
4691 | |
4692 //set defaults, might be overriden a few line later | |
4693 h->ref_count[0]= h->pps.ref_count[0]; | |
4694 h->ref_count[1]= h->pps.ref_count[1]; | |
4695 | |
4696 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4697 if(h->slice_type == B_TYPE){ | |
4698 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4699 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4700 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4701 } |
4702 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4703 |
1168 | 4704 if(num_ref_idx_active_override_flag){ |
4705 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4706 if(h->slice_type==B_TYPE) | |
4707 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4708 | |
4709 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
|
4710 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4711 h->ref_count[0]= h->ref_count[1]= 1; |
1168 | 4712 return -1; |
4713 } | |
4714 } | |
4715 } | |
4716 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4717 if(!default_ref_list_done){ |
1168 | 4718 fill_default_ref_list(h); |
4719 } | |
4720 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4721 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
|
4722 return -1; |
1168 | 4723 |
2967 | 4724 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4725 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4726 pred_weight_table(h); | |
2415 | 4727 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4728 implicit_weight_table(h); | |
4729 else | |
4730 h->use_weight = 0; | |
2967 | 4731 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4732 if(s->current_picture.reference) |
1168 | 4733 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
|
4734 |
3316 | 4735 if(FRAME_MBAFF) |
4736 fill_mbaff_ref_list(h); | |
4737 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4738 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac ){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4739 tmp = get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4740 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4741 av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4742 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4743 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4744 h->cabac_init_idc= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4745 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4746 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4747 h->last_qscale_diff = 0; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4748 tmp = h->pps.init_qp + get_se_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4749 if(tmp>51){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4750 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); |
1898 | 4751 return -1; |
4752 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4753 s->qscale= tmp; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4754 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4755 //FIXME qscale / qp ... stuff |
4756 if(h->slice_type == SP_TYPE){ | |
1453 | 4757 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4758 } |
4759 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4760 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4761 } |
4762 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4763 h->deblocking_filter = 1; |
1898 | 4764 h->slice_alpha_c0_offset = 0; |
4765 h->slice_beta_offset = 0; | |
1168 | 4766 if( h->pps.deblocking_filter_parameters_present ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4767 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4768 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4769 av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4770 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4771 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4772 h->deblocking_filter= tmp; |
2967 | 4773 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
|
4774 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
|
4775 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4776 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
|
4777 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
|
4778 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4779 } |
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
|
4780 } |
2792 | 4781 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4782 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4783 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4784 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4785 h->deblocking_filter= 0; | |
1168 | 4786 |
4787 #if 0 //FMO | |
4788 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4789 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4790 #endif | |
4791 | |
2392 | 4792 h->slice_num++; |
4793 | |
3316 | 4794 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4795 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4796 | |
1168 | 4797 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4798 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n", |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4799 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4800 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4801 first_mb_in_slice, |
1264 | 4802 av_get_pict_type_char(h->slice_type), |
1168 | 4803 pps_id, h->frame_num, |
4804 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4805 h->ref_count[0], h->ref_count[1], | |
4806 s->qscale, | |
2583 | 4807 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4808 h->use_weight, |
4809 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4810 ); |
4811 } | |
4812 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4813 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
|
4814 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
|
4815 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
|
4816 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4817 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
|
4818 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
|
4819 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4820 |
1168 | 4821 return 0; |
4822 } | |
4823 | |
4824 /** | |
4825 * | |
4826 */ | |
4827 static inline int get_level_prefix(GetBitContext *gb){ | |
4828 unsigned int buf; | |
4829 int log; | |
2967 | 4830 |
1168 | 4831 OPEN_READER(re, gb); |
4832 UPDATE_CACHE(re, gb); | |
4833 buf=GET_CACHE(re, gb); | |
2967 | 4834 |
1168 | 4835 log= 32 - av_log2(buf); |
4836 #ifdef TRACE | |
4837 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
|
4838 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 | 4839 #endif |
4840 | |
4841 LAST_SKIP_BITS(re, gb, log); | |
4842 CLOSE_READER(re, gb); | |
4843 | |
4844 return log-1; | |
4845 } | |
4846 | |
2755 | 4847 static inline int get_dct8x8_allowed(H264Context *h){ |
4848 int i; | |
4849 for(i=0; i<4; i++){ | |
4850 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
|
4851 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4852 return 0; |
4853 } | |
4854 return 1; | |
4855 } | |
4856 | |
1168 | 4857 /** |
4858 * decodes a residual block. | |
4859 * @param n block index | |
4860 * @param scantable scantable | |
4861 * @param max_coeff number of coefficients in the block | |
4862 * @return <0 if an error occured | |
4863 */ | |
2919 | 4864 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4865 MpegEncContext * const s = &h->s; |
4866 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 | 4867 int level[16]; |
4868 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4869 |
4870 //FIXME put trailing_onex into the context | |
4871 | |
4872 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4873 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4874 total_coeff= coeff_token>>2; | |
2967 | 4875 }else{ |
1168 | 4876 if(n == LUMA_DC_BLOCK_INDEX){ |
4877 total_coeff= pred_non_zero_count(h, 0); | |
4878 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4879 total_coeff= coeff_token>>2; | |
4880 }else{ | |
4881 total_coeff= pred_non_zero_count(h, n); | |
4882 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4883 total_coeff= coeff_token>>2; | |
4884 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4885 } | |
4886 } | |
4887 | |
4888 //FIXME set last_non_zero? | |
4889 | |
4890 if(total_coeff==0) | |
4891 return 0; | |
4391
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4892 if(total_coeff > (unsigned)max_coeff) { |
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4893 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff); |
4270 | 4894 return -1; |
4895 } | |
2967 | 4896 |
1168 | 4897 trailing_ones= coeff_token&3; |
1170 | 4898 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4899 assert(total_coeff<=16); |
2967 | 4900 |
1168 | 4901 for(i=0; i<trailing_ones; i++){ |
4902 level[i]= 1 - 2*get_bits1(gb); | |
4903 } | |
4904 | |
2897 | 4905 if(i<total_coeff) { |
1168 | 4906 int level_code, mask; |
2897 | 4907 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4908 int prefix= get_level_prefix(gb); | |
4909 | |
4910 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4911 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4912 if(suffix_length) | |
4913 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4914 else | |
4915 level_code= (prefix<<suffix_length); //part | |
4916 }else if(prefix==14){ | |
4917 if(suffix_length) | |
4918 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4919 else | |
4920 level_code= prefix + get_bits(gb, 4); //part | |
4921 }else if(prefix==15){ | |
4922 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
|
4923 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4924 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4925 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4926 return -1; |
4927 } | |
4928 | |
2897 | 4929 if(trailing_ones < 3) level_code += 2; |
4930 | |
4931 suffix_length = 1; | |
4932 if(level_code > 5) | |
4933 suffix_length++; | |
1168 | 4934 mask= -(level_code&1); |
4935 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4936 i++; |
4937 | |
4938 //remaining coefficients have suffix_length > 0 | |
4939 for(;i<total_coeff;i++) { | |
4940 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4941 prefix = get_level_prefix(gb); | |
4942 if(prefix<15){ | |
4943 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4944 }else if(prefix==15){ | |
4945 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4946 }else{ | |
4947 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4948 return -1; | |
4949 } | |
4950 mask= -(level_code&1); | |
4951 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4952 if(level_code > suffix_limit[suffix_length]) | |
4953 suffix_length++; | |
4954 } | |
1168 | 4955 } |
4956 | |
4957 if(total_coeff == max_coeff) | |
4958 zeros_left=0; | |
4959 else{ | |
4960 if(n == CHROMA_DC_BLOCK_INDEX) | |
4961 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4962 else | |
4963 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4964 } | |
2897 | 4965 |
4966 coeff_num = zeros_left + total_coeff - 1; | |
4967 j = scantable[coeff_num]; | |
4968 if(n > 24){ | |
4969 block[j] = level[0]; | |
4970 for(i=1;i<total_coeff;i++) { | |
4971 if(zeros_left <= 0) | |
4972 run_before = 0; | |
4973 else if(zeros_left < 7){ | |
4974 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4975 }else{ | |
4976 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4977 } | |
4978 zeros_left -= run_before; | |
4979 coeff_num -= 1 + run_before; | |
4980 j= scantable[ coeff_num ]; | |
4981 | |
4982 block[j]= level[i]; | |
4983 } | |
4984 }else{ | |
2919 | 4985 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4986 for(i=1;i<total_coeff;i++) { |
4987 if(zeros_left <= 0) | |
4988 run_before = 0; | |
4989 else if(zeros_left < 7){ | |
4990 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4991 }else{ | |
4992 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4993 } | |
4994 zeros_left -= run_before; | |
4995 coeff_num -= 1 + run_before; | |
4996 j= scantable[ coeff_num ]; | |
4997 | |
2919 | 4998 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 4999 } |
1168 | 5000 } |
5001 | |
5002 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5003 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 5004 return -1; |
5005 } | |
2897 | 5006 |
1168 | 5007 return 0; |
5008 } | |
5009 | |
3316 | 5010 static void predict_field_decoding_flag(H264Context *h){ |
5011 MpegEncContext * const s = &h->s; | |
5012 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
5013 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
5014 ? s->current_picture.mb_type[mb_xy-1] | |
5015 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
5016 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
5017 : 0; | |
5018 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
5019 } | |
5020 | |
1168 | 5021 /** |
2396 | 5022 * decodes a P_SKIP or B_SKIP macroblock |
5023 */ | |
5024 static void decode_mb_skip(H264Context *h){ | |
5025 MpegEncContext * const s = &h->s; | |
5026 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
|
5027 int mb_type=0; |
2967 | 5028 |
2396 | 5029 memset(h->non_zero_count[mb_xy], 0, 16); |
5030 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
5031 | |
3316 | 5032 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5033 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5034 |
2396 | 5035 if( h->slice_type == B_TYPE ) |
5036 { | |
5037 // 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
|
5038 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5039 |
2449 | 5040 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5041 pred_direct_motion(h, &mb_type); |
3927 | 5042 mb_type|= MB_TYPE_SKIP; |
2396 | 5043 } |
5044 else | |
5045 { | |
5046 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5047 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5048 |
2449 | 5049 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5050 pred_pskip_motion(h, &mx, &my); |
5051 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5052 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5053 } | |
5054 | |
5055 write_back_motion(h, mb_type); | |
3927 | 5056 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5057 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5058 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
|
5059 h->prev_mb_skipped= 1; |
2396 | 5060 } |
5061 | |
5062 /** | |
1168 | 5063 * decodes a macroblock |
5064 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5065 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5066 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5067 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
|
5068 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5069 int partition_count; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5070 unsigned int mb_type, cbp; |
2755 | 5071 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5072 |
2967 | 5073 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5074 |
1170 | 5075 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5076 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5077 down the code */ | |
1168 | 5078 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5079 if(s->mb_skip_run==-1) | |
5080 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5081 |
1168 | 5082 if (s->mb_skip_run--) { |
3316 | 5083 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5084 if(s->mb_skip_run==0) | |
5085 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5086 else | |
5087 predict_field_decoding_flag(h); | |
5088 } | |
2396 | 5089 decode_mb_skip(h); |
1168 | 5090 return 0; |
5091 } | |
5092 } | |
3316 | 5093 if(FRAME_MBAFF){ |
5094 if( (s->mb_y&1) == 0 ) | |
5095 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5096 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5097 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5098 |
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
|
5099 h->prev_mb_skipped= 0; |
2967 | 5100 |
1168 | 5101 mb_type= get_ue_golomb(&s->gb); |
5102 if(h->slice_type == B_TYPE){ | |
5103 if(mb_type < 23){ | |
5104 partition_count= b_mb_type_info[mb_type].partition_count; | |
5105 mb_type= b_mb_type_info[mb_type].type; | |
5106 }else{ | |
5107 mb_type -= 23; | |
5108 goto decode_intra_mb; | |
5109 } | |
5110 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5111 if(mb_type < 5){ | |
5112 partition_count= p_mb_type_info[mb_type].partition_count; | |
5113 mb_type= p_mb_type_info[mb_type].type; | |
5114 }else{ | |
5115 mb_type -= 5; | |
5116 goto decode_intra_mb; | |
5117 } | |
5118 }else{ | |
5119 assert(h->slice_type == I_TYPE); | |
5120 decode_intra_mb: | |
5121 if(mb_type > 25){ | |
3954 | 5122 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 | 5123 return -1; |
5124 } | |
5125 partition_count=0; | |
5126 cbp= i_mb_type_info[mb_type].cbp; | |
5127 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5128 mb_type= i_mb_type_info[mb_type].type; | |
5129 } | |
5130 | |
3316 | 5131 if(MB_FIELD) |
1168 | 5132 mb_type |= MB_TYPE_INTERLACED; |
5133 | |
5134 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5135 |
1168 | 5136 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5137 unsigned int x, y; |
2967 | 5138 |
1168 | 5139 // we assume these blocks are very rare so we dont optimize it |
5140 align_get_bits(&s->gb); | |
2967 | 5141 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5142 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5143 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5144 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5145 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5146 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
|
5147 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5148 } |
5149 } | |
5150 for(y=0; y<8; y++){ | |
5151 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5152 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5153 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
|
5154 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5155 } |
5156 } | |
5157 for(y=0; y<8; y++){ | |
5158 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5159 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5160 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
|
5161 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5162 } |
5163 } | |
2967 | 5164 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5165 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5166 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
|
5167 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
|
5168 // 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
|
5169 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5170 |
2755 | 5171 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5172 return 0; |
5173 } | |
2967 | 5174 |
3316 | 5175 if(MB_MBAFF){ |
5176 h->ref_count[0] <<= 1; | |
5177 h->ref_count[1] <<= 1; | |
5178 } | |
5179 | |
2449 | 5180 fill_caches(h, mb_type, 0); |
1168 | 5181 |
5182 //mb_pred | |
5183 if(IS_INTRA(mb_type)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5184 int pred_mode; |
1168 | 5185 // init_top_left_availability(h); |
5186 if(IS_INTRA4x4(mb_type)){ | |
5187 int i; | |
2755 | 5188 int di = 1; |
5189 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5190 mb_type |= MB_TYPE_8x8DCT; | |
5191 di = 4; | |
5192 } | |
1168 | 5193 |
5194 // fill_intra4x4_pred_table(h); | |
2755 | 5195 for(i=0; i<16; i+=di){ |
3409 | 5196 int mode= pred_intra_mode(h, i); |
5197 | |
5198 if(!get_bits1(&s->gb)){ | |
1168 | 5199 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5200 mode = rem_mode + (rem_mode >= mode); |
1168 | 5201 } |
2967 | 5202 |
2755 | 5203 if(di==4) |
5204 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5205 else | |
5206 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5207 } |
5208 write_back_intra_pred_mode(h); | |
5209 if( check_intra4x4_pred_mode(h) < 0) | |
5210 return -1; | |
5211 }else{ | |
5212 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5213 if(h->intra16x16_pred_mode < 0) | |
5214 return -1; | |
5215 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5216 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5217 pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb)); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5218 if(pred_mode < 0) |
1168 | 5219 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5220 h->chroma_pred_mode= pred_mode; |
1168 | 5221 }else if(partition_count==4){ |
5222 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5223 |
1168 | 5224 if(h->slice_type == B_TYPE){ |
5225 for(i=0; i<4; i++){ | |
5226 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5227 if(h->sub_mb_type[i] >=13){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5228 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5229 return -1; |
5230 } | |
5231 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5232 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5233 } | |
2396 | 5234 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5235 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5236 pred_direct_motion(h, &mb_type); |
3003 | 5237 h->ref_cache[0][scan8[4]] = |
5238 h->ref_cache[1][scan8[4]] = | |
5239 h->ref_cache[0][scan8[12]] = | |
5240 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5241 } | |
1168 | 5242 }else{ |
5243 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5244 for(i=0; i<4; i++){ | |
5245 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5246 if(h->sub_mb_type[i] >=4){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5247 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5248 return -1; |
5249 } | |
5250 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5251 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5252 } | |
5253 } | |
2967 | 5254 |
1168 | 5255 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
|
5256 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5257 if(ref_count == 0) continue; |
5258 for(i=0; i<4; i++){ | |
2396 | 5259 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5260 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5261 unsigned int tmp = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5262 if(tmp>=ref_count){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5263 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5264 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5265 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5266 ref[list][i]= tmp; |
1168 | 5267 }else{ |
5268 //FIXME | |
5269 ref[list][i] = -1; | |
5270 } | |
5271 } | |
5272 } | |
2967 | 5273 |
2755 | 5274 if(dct8x8_allowed) |
5275 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5276 |
1168 | 5277 for(list=0; list<2; list++){ |
5278 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
5279 if(ref_count == 0) continue; | |
5280 | |
5281 for(i=0; i<4; i++){ | |
3003 | 5282 if(IS_DIRECT(h->sub_mb_type[i])) { |
5283 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5284 continue; | |
5285 } | |
1168 | 5286 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5287 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5288 | |
2396 | 5289 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5290 const int sub_mb_type= h->sub_mb_type[i]; |
5291 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5292 for(j=0; j<sub_partition_count[i]; j++){ | |
5293 int mx, my; | |
5294 const int index= 4*i + block_width*j; | |
5295 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5296 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5297 mx += get_se_golomb(&s->gb); | |
5298 my += get_se_golomb(&s->gb); | |
1170 | 5299 tprintf("final mv:%d %d\n", mx, my); |
5300 | |
1168 | 5301 if(IS_SUB_8X8(sub_mb_type)){ |
2967 | 5302 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
1168 | 5303 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
2967 | 5304 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
1168 | 5305 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5306 }else if(IS_SUB_8X4(sub_mb_type)){ | |
5307 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; | |
5308 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; | |
5309 }else if(IS_SUB_4X8(sub_mb_type)){ | |
5310 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; | |
5311 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; | |
5312 }else{ | |
5313 assert(IS_SUB_4X4(sub_mb_type)); | |
5314 mv_cache[ 0 ][0]= mx; | |
5315 mv_cache[ 0 ][1]= my; | |
5316 } | |
5317 } | |
5318 }else{ | |
5319 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5320 p[0] = p[1]= | |
5321 p[8] = p[9]= 0; | |
5322 } | |
5323 } | |
5324 } | |
2396 | 5325 }else if(IS_DIRECT(mb_type)){ |
5326 pred_direct_motion(h, &mb_type); | |
2755 | 5327 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5328 }else{ |
1168 | 5329 int list, mx, my, i; |
5330 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5331 if(IS_16X16(mb_type)){ | |
5332 for(list=0; list<2; list++){ | |
2392 | 5333 if(h->ref_count[list]>0){ |
1168 | 5334 if(IS_DIR(mb_type, 0, list)){ |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5335 unsigned int val= get_te0_golomb(&s->gb, h->ref_count[list]); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5336 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5337 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5338 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5339 } |
1168 | 5340 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); |
2523 | 5341 }else |
5342 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 5343 } |
5344 } | |
5345 for(list=0; list<2; list++){ | |
5346 if(IS_DIR(mb_type, 0, list)){ | |
5347 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5348 mx += get_se_golomb(&s->gb); | |
5349 my += get_se_golomb(&s->gb); | |
1170 | 5350 tprintf("final mv:%d %d\n", mx, my); |
5351 | |
1269 | 5352 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5353 }else |
5354 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1168 | 5355 } |
5356 } | |
5357 else if(IS_16X8(mb_type)){ | |
5358 for(list=0; list<2; list++){ | |
5359 if(h->ref_count[list]>0){ | |
5360 for(i=0; i<2; i++){ | |
5361 if(IS_DIR(mb_type, i, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5362 unsigned int val= get_te0_golomb(&s->gb, h->ref_count[list]); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5363 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5364 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5365 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5366 } |
1168 | 5367 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); |
2523 | 5368 }else |
2396 | 5369 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5370 } |
5371 } | |
5372 } | |
5373 for(list=0; list<2; list++){ | |
5374 for(i=0; i<2; i++){ | |
5375 if(IS_DIR(mb_type, i, list)){ | |
5376 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5377 mx += get_se_golomb(&s->gb); | |
5378 my += get_se_golomb(&s->gb); | |
1170 | 5379 tprintf("final mv:%d %d\n", mx, my); |
5380 | |
1269 | 5381 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5382 }else |
5383 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 5384 } |
5385 } | |
5386 }else{ | |
5387 assert(IS_8X16(mb_type)); | |
5388 for(list=0; list<2; list++){ | |
5389 if(h->ref_count[list]>0){ | |
5390 for(i=0; i<2; i++){ | |
5391 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5392 unsigned int val= get_te0_golomb(&s->gb, h->ref_count[list]); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5393 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5394 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5395 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5396 } |
1168 | 5397 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); |
2523 | 5398 }else |
2396 | 5399 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5400 } |
5401 } | |
5402 } | |
5403 for(list=0; list<2; list++){ | |
5404 for(i=0; i<2; i++){ | |
5405 if(IS_DIR(mb_type, i, list)){ | |
5406 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5407 mx += get_se_golomb(&s->gb); | |
5408 my += get_se_golomb(&s->gb); | |
1170 | 5409 tprintf("final mv:%d %d\n", mx, my); |
5410 | |
1269 | 5411 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5412 }else |
5413 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 5414 } |
5415 } | |
5416 } | |
5417 } | |
2967 | 5418 |
1168 | 5419 if(IS_INTER(mb_type)) |
5420 write_back_motion(h, mb_type); | |
2967 | 5421 |
1168 | 5422 if(!IS_INTRA16x16(mb_type)){ |
5423 cbp= get_ue_golomb(&s->gb); | |
5424 if(cbp > 47){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5425 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5426 return -1; |
5427 } | |
2967 | 5428 |
1168 | 5429 if(IS_INTRA4x4(mb_type)) |
5430 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5431 else | |
5432 cbp= golomb_to_inter_cbp[cbp]; | |
5433 } | |
3651 | 5434 h->cbp = cbp; |
1168 | 5435 |
2755 | 5436 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5437 if(get_bits1(&s->gb)) | |
5438 mb_type |= MB_TYPE_8x8DCT; | |
5439 } | |
5440 s->current_picture.mb_type[mb_xy]= mb_type; | |
5441 | |
1168 | 5442 if(cbp || IS_INTRA16x16(mb_type)){ |
5443 int i8x8, i4x4, chroma_idx; | |
5444 int chroma_qp, dquant; | |
5445 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5446 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5447 |
1168 | 5448 // fill_non_zero_count_cache(h); |
5449 | |
5450 if(IS_INTERLACED(mb_type)){ | |
3316 | 5451 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5452 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5453 dc_scan= luma_dc_field_scan; |
5454 }else{ | |
3316 | 5455 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5456 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5457 dc_scan= luma_dc_zigzag_scan; |
5458 } | |
5459 | |
5460 dquant= get_se_golomb(&s->gb); | |
5461 | |
5462 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5463 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 | 5464 return -1; |
5465 } | |
2967 | 5466 |
1168 | 5467 s->qscale += dquant; |
5468 if(((unsigned)s->qscale) > 51){ | |
5469 if(s->qscale<0) s->qscale+= 52; | |
5470 else s->qscale-= 52; | |
5471 } | |
2967 | 5472 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5473 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5474 if(IS_INTRA16x16(mb_type)){ |
2919 | 5475 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
|
5476 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5477 } |
5478 | |
5479 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5480 | |
5481 if(cbp&15){ | |
5482 for(i8x8=0; i8x8<4; i8x8++){ | |
5483 for(i4x4=0; i4x4<4; i4x4++){ | |
5484 const int index= i4x4 + 4*i8x8; | |
2919 | 5485 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5486 return -1; |
5487 } | |
5488 } | |
5489 } | |
5490 }else{ | |
1636 | 5491 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5492 } |
5493 }else{ | |
5494 for(i8x8=0; i8x8<4; i8x8++){ | |
5495 if(cbp & (1<<i8x8)){ | |
2755 | 5496 if(IS_8x8DCT(mb_type)){ |
5497 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5498 uint8_t *nnz; |
2755 | 5499 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5500 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5501 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5502 return -1; |
5503 } | |
2757 | 5504 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
|
5505 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5506 }else{ |
5507 for(i4x4=0; i4x4<4; i4x4++){ | |
5508 const int index= i4x4 + 4*i8x8; | |
2967 | 5509 |
2919 | 5510 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 | 5511 return -1; |
5512 } | |
1168 | 5513 } |
5514 } | |
5515 }else{ | |
5516 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5517 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5518 } | |
5519 } | |
5520 } | |
2967 | 5521 |
1168 | 5522 if(cbp&0x30){ |
5523 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5524 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5525 return -1; |
5526 } | |
5527 } | |
5528 | |
5529 if(cbp&0x20){ | |
5530 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5531 for(i4x4=0; i4x4<4; i4x4++){ | |
5532 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5533 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 | 5534 return -1; |
5535 } | |
5536 } | |
5537 } | |
5538 }else{ | |
5539 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5540 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5541 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5542 } | |
5543 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5544 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
|
5545 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
|
5546 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
|
5547 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5548 } |
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
|
5549 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5550 write_back_non_zero_count(h); |
5551 | |
3316 | 5552 if(MB_MBAFF){ |
5553 h->ref_count[0] >>= 1; | |
5554 h->ref_count[1] >>= 1; | |
5555 } | |
5556 | |
1168 | 5557 return 0; |
5558 } | |
5559 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5560 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
|
5561 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
|
5562 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
|
5563 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
|
5564 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
|
5565 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
|
5566 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5567 unsigned int ctx = 0; |
2967 | 5568 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5569 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
|
5570 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5571 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5572 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
|
5573 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5574 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5575 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5576 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
|
5577 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5578 |
2312 | 5579 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5580 uint8_t *state= &h->cabac_state[ctx_base]; | |
5581 int mb_type; | |
2967 | 5582 |
2312 | 5583 if(intra_slice){ |
5584 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
|
5585 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
|
5586 const int mbb_xy = h->top_mb_xy; |
2312 | 5587 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5588 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
|
5589 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5590 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
|
5591 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5592 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5593 return 0; /* I4x4 */ |
5594 state += 2; | |
5595 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5596 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
|
5597 return 0; /* I4x4 */ |
2312 | 5598 } |
5599 | |
5600 if( get_cabac_terminate( &h->cabac ) ) | |
5601 return 25; /* PCM */ | |
5602 | |
5603 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
|
5604 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
|
5605 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
|
5606 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
|
5607 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
|
5608 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5609 return mb_type; |
5610 } | |
5611 | |
5612 static int decode_cabac_mb_type( H264Context *h ) { | |
5613 MpegEncContext * const s = &h->s; | |
5614 | |
5615 if( h->slice_type == I_TYPE ) { | |
5616 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
|
5617 } 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
|
5618 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
|
5619 /* 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
|
5620 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5621 /* 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
|
5622 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
|
5623 } else { |
3138 | 5624 /* 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
|
5625 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
|
5626 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5627 } else { |
2312 | 5628 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
|
5629 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5630 } 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
|
5631 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
|
5632 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
|
5633 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
|
5634 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5635 |
3138 | 5636 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
|
5637 ctx++; |
3138 | 5638 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
|
5639 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5640 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5641 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
|
5642 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
|
5643 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5644 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
|
5645 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
|
5646 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5647 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5648 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
|
5649 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
|
5650 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
|
5651 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
|
5652 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
|
5653 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
|
5654 else if( bits == 13 ) { |
2312 | 5655 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
|
5656 } 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
|
5657 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
|
5658 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
|
5659 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
|
5660 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5661 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
|
5662 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
|
5663 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5664 /* 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
|
5665 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
|
5666 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5667 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5668 |
3316 | 5669 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
|
5670 MpegEncContext * const s = &h->s; |
3316 | 5671 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
|
5672 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
|
5673 |
3316 | 5674 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5675 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5676 mba_xy = mb_xy - 1; | |
5677 if( (mb_y&1) | |
5678 && h->slice_table[mba_xy] == h->slice_num | |
5679 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5680 mba_xy += s->mb_stride; | |
5681 if( MB_FIELD ){ | |
5682 mbb_xy = mb_xy - s->mb_stride; | |
5683 if( !(mb_y&1) | |
5684 && h->slice_table[mbb_xy] == h->slice_num | |
5685 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5686 mbb_xy -= s->mb_stride; | |
5687 }else | |
5688 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5689 }else{ | |
5690 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5691 mba_xy = mb_xy - 1; | |
5692 mbb_xy = mb_xy - s->mb_stride; | |
5693 } | |
5694 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5695 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
|
5696 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5697 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
|
5698 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5699 |
3138 | 5700 if( h->slice_type == B_TYPE ) |
5701 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
|
5702 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
|
5703 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5704 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5705 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
|
5706 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
|
5707 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5708 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
|
5709 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
|
5710 |
2928 | 5711 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5712 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5713 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5714 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5715 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
|
5716 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
|
5717 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5718 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
|
5719 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5720 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5721 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
|
5722 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
|
5723 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
|
5724 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5725 int 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
|
5726 |
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
|
5727 /* 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
|
5728 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
|
5729 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
|
5730 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5731 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
|
5732 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5733 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5734 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
|
5735 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
|
5736 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5737 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
|
5738 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
|
5739 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
|
5740 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
|
5741 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5742 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
|
5743 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5744 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5745 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
|
5746 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
|
5747 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5748 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
|
5749 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
|
5750 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5751 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
|
5752 { 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
|
5753 { 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
|
5754 { 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
|
5755 { 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
|
5756 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5757 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5758 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
|
5759 int cbp = 0; |
3138 | 5760 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
|
5761 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
|
5762 |
3138 | 5763 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5764 cbp_b = h->top_cbp; | |
5765 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5766 } | |
5767 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5768 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
|
5769 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
|
5770 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
|
5771 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
|
5772 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5773 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
|
5774 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
|
5775 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5776 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
|
5777 cbp_a = cbp; |
3138 | 5778 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
|
5779 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
|
5780 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
|
5781 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5782 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5783 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
|
5784 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
|
5785 |
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
|
5786 /* 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
|
5787 /* 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
|
5788 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
|
5789 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
|
5790 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
|
5791 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5792 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5793 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5794 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
|
5795 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
|
5796 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
|
5797 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
|
5798 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5799 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5800 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
|
5801 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
|
5802 } |
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 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
|
5805 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5806 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
|
5807 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
|
5808 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
|
5809 |
2314 | 5810 cbp_a = (h->left_cbp>>4)&0x03; |
5811 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
|
5812 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5813 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
|
5814 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
|
5815 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
|
5816 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
|
5817 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
|
5818 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5819 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
|
5820 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
|
5821 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
|
5822 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
|
5823 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5824 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
|
5825 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
|
5826 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
|
5827 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
|
5828 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
|
5829 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5830 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
|
5831 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
|
5832 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5833 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
|
5834 |
3316 | 5835 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
|
5836 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5837 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5838 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
|
5839 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
|
5840 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
|
5841 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5842 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
|
5843 val++; |
3128 | 5844 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5845 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
|
5846 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5847 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5848 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
|
5849 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
|
5850 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5851 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
|
5852 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5853 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
|
5854 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
|
5855 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
|
5856 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
|
5857 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
|
5858 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
|
5859 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
|
5860 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
|
5861 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5862 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
|
5863 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5864 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
|
5865 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
|
5866 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
|
5867 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
|
5868 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5869 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
|
5870 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
|
5871 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
|
5872 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5873 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5874 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
|
5875 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
|
5876 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5877 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5878 |
2755 | 5879 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
|
5880 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5881 } |
5882 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5883 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
|
5884 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
|
5885 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
|
5886 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
|
5887 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
|
5888 |
2396 | 5889 if( h->slice_type == B_TYPE) { |
5890 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5891 ctx++; | |
5892 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5893 ctx += 2; | |
5894 } else { | |
5895 if( refa > 0 ) | |
5896 ctx++; | |
5897 if( refb > 0 ) | |
5898 ctx += 2; | |
5899 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5900 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5901 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
|
5902 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5903 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
|
5904 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5905 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5906 ctx = 5; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5907 if(ref >= 32 /*h->ref_list[list]*/){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5908 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_ref\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5909 return 0; //FIXME we should return -1 and check the return everywhere |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5910 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5911 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5912 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5913 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5914 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5915 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
|
5916 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
|
5917 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
|
5918 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5919 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
|
5920 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5921 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
|
5922 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5923 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
|
5924 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5925 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5926 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5927 |
2317 | 5928 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5929 return 0; | |
5930 | |
5931 mvd= 1; | |
5932 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
|
5933 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
|
5934 mvd++; |
2317 | 5935 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
|
5936 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5937 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5938 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5939 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
|
5940 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
|
5941 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
|
5942 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
|
5943 k++; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5944 if(k>24){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5945 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5946 return INT_MIN; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5947 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5948 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5949 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5950 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
|
5951 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
|
5952 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5953 } |
4042 | 5954 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
|
5955 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5956 |
2316 | 5957 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5958 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
|
5959 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
|
5960 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5961 if( cat == 0 ) { |
2314 | 5962 nza = h->left_cbp&0x100; |
5963 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
|
5964 } else if( cat == 1 || cat == 2 ) { |
2314 | 5965 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5966 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
|
5967 } else if( cat == 3 ) { |
2314 | 5968 nza = (h->left_cbp>>(6+idx))&0x01; |
5969 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5970 } else { | |
5971 assert(cat == 4); | |
5972 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5973 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5974 } | |
5975 | |
5976 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
|
5977 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5978 |
2314 | 5979 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
|
5980 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
|
5981 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5982 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
|
5983 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5984 |
4051 | 5985 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
5986 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
5987 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
5988 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
5989 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
5990 }; | |
5991 | |
3028 | 5992 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
|
5993 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5994 static const int significant_coeff_flag_offset[2][6] = { |
5995 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
5996 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
5997 }; | |
5998 static const int last_coeff_flag_offset[2][6] = { | |
5999 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
6000 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
6001 }; | |
6002 static const int coeff_abs_level_m1_offset[6] = { | |
6003 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
6004 }; | |
4007 | 6005 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 6006 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 6007 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
6008 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 6009 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
6010 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
6011 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
6012 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
6013 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 6014 }; |
6015 | |
6016 int index[64]; | |
2313 | 6017 |
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
|
6018 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
|
6019 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
|
6020 |
2316 | 6021 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
|
6022 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
|
6023 |
2898 | 6024 uint8_t *significant_coeff_ctx_base; |
6025 uint8_t *last_coeff_ctx_base; | |
6026 uint8_t *abs_level_m1_ctx_base; | |
2755 | 6027 |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
6028 #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
|
6029 #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
|
6030 #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
|
6031 #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
|
6032 #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
|
6033 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
|
6034 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
|
6035 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
|
6036 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
|
6037 #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
|
6038 #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
|
6039 #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
|
6040 |
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
|
6041 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6042 /* 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
|
6043 * 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
|
6044 * 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
|
6045 * 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
|
6046 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 6047 * 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
|
6048 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6049 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6050 /* read coded block flag */ |
2898 | 6051 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
|
6052 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 6053 if( cat == 1 || cat == 2 ) |
6054 h->non_zero_count_cache[scan8[n]] = 0; | |
6055 else if( cat == 4 ) | |
6056 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
|
6057 #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
|
6058 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
|
6059 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
|
6060 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
|
6061 #endif |
2755 | 6062 return 0; |
6063 } | |
2898 | 6064 } |
6065 | |
6066 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6067 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6068 last_coeff_ctx_base = h->cabac_state |
3316 | 6069 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6070 abs_level_m1_ctx_base = h->cabac_state |
6071 + coeff_abs_level_m1_offset[cat]; | |
6072 | |
6073 if( cat == 5 ) { | |
6074 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6075 for(last= 0; last < coefs; last++) { \ | |
6076 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
|
6077 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6078 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6079 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
|
6080 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6081 last= max_coeff; \ |
6082 break; \ | |
6083 } \ | |
6084 } \ | |
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
|
6085 }\ |
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
|
6086 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
|
6087 index[coeff_count++] = last;\ |
2898 | 6088 } |
4009 | 6089 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
|
6090 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6091 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6092 } else { | |
6093 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6094 #else | |
3316 | 6095 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6096 } else { |
6097 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
|
6098 #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
|
6099 } |
2316 | 6100 assert(coeff_count > 0); |
6101 | |
6102 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
|
6103 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
|
6104 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
|
6105 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6106 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
|
6107 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6108 else if( cat == 4 ) |
6109 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6110 else { |
2755 | 6111 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6112 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6113 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6114 |
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
|
6115 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6116 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
|
6117 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
|
6118 |
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
|
6119 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6120 if( !qmul ) { |
4040 | 6121 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6122 }else{ |
4040 | 6123 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6124 } |
2967 | 6125 |
2313 | 6126 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
|
6127 } else { |
2313 | 6128 int coeff_abs = 2; |
2898 | 6129 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
|
6130 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6131 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
|
6132 } |
2313 | 6133 |
6134 if( coeff_abs >= 15 ) { | |
6135 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
|
6136 while( get_cabac_bypass( CC ) ) { |
2313 | 6137 j++; |
6138 } | |
2967 | 6139 |
4016 | 6140 coeff_abs=1; |
2313 | 6141 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
|
6142 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6143 } |
4016 | 6144 coeff_abs+= 14; |
2313 | 6145 } |
6146 | |
2898 | 6147 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
|
6148 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6149 else block[j] = coeff_abs; |
6150 }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
|
6151 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6152 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6153 } |
2967 | 6154 |
2313 | 6155 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
|
6156 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6157 } |
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
|
6158 #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
|
6159 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
|
6160 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
|
6161 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
|
6162 #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
|
6163 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
|
6164 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6165 |
3077 | 6166 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
|
6167 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6168 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
|
6169 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
|
6170 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
|
6171 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6172 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
|
6173 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
|
6174 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
|
6175 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
|
6176 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6177 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
|
6178 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
|
6179 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6180 ? !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
|
6181 : (!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
|
6182 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6183 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
|
6184 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6185 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
|
6186 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
|
6187 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6188 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6189 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6190 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6191 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6192 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6193 * 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
|
6194 * @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
|
6195 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6196 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
|
6197 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
|
6198 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
|
6199 int mb_type, partition_count, cbp = 0; |
2755 | 6200 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
|
6201 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6202 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
|
6203 |
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
|
6204 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
|
6205 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6206 int skip; |
6207 /* a skipped mb needs the aff flag from the following mb */ | |
6208 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6209 predict_field_decoding_flag(h); | |
6210 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6211 skip = h->next_mb_skipped; | |
6212 else | |
6213 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
|
6214 /* read skip flags */ |
3316 | 6215 if( skip ) { |
6216 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6217 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6218 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6219 if(h->next_mb_skipped) | |
6220 predict_field_decoding_flag(h); | |
6221 else | |
6222 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6223 } | |
6224 | |
2396 | 6225 decode_mb_skip(h); |
6226 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6227 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
|
6228 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
|
6229 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
|
6230 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6231 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
|
6232 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6233 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6234 } |
3316 | 6235 if(FRAME_MBAFF){ |
6236 if( (s->mb_y&1) == 0 ) | |
6237 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
|
6238 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
|
6239 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6240 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
|
6241 |
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
|
6242 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
|
6243 |
3077 | 6244 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
|
6245 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
|
6246 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
|
6247 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
|
6248 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6249 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6250 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
|
6251 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
|
6252 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
|
6253 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
|
6254 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6255 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
|
6256 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
|
6257 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6258 } 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
|
6259 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
|
6260 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
|
6261 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
|
6262 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6263 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
|
6264 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
|
6265 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6266 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6267 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
|
6268 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
|
6269 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
|
6270 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
|
6271 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
|
6272 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
|
6273 } |
3316 | 6274 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
|
6275 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
|
6276 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6277 h->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
|
6278 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6279 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6280 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6281 unsigned int x, y; |
2967 | 6282 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6283 // 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
|
6284 // 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
|
6285 // 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
|
6286 ptr= h->cabac.bytestream; |
4344 | 6287 if(h->cabac.low&0x1) ptr--; |
6288 if(CABAC_BITS==16){ | |
6289 if(h->cabac.low&0x1FF) ptr--; | |
6290 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6291 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6292 // 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
|
6293 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6294 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
|
6295 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6296 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6297 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
|
6298 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6299 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6300 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6301 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
|
6302 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6303 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
|
6304 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
|
6305 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6306 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6307 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6308 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
|
6309 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6310 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
|
6311 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
|
6312 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6313 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6314 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6315 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
|
6316 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6317 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6318 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
|
6319 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
|
6320 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6321 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
|
6322 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
|
6323 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6324 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6325 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
|
6326 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
|
6327 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6328 |
3316 | 6329 if(MB_MBAFF){ |
6330 h->ref_count[0] <<= 1; | |
6331 h->ref_count[1] <<= 1; | |
6332 } | |
6333 | |
2449 | 6334 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
|
6335 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6336 if( IS_INTRA( mb_type ) ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6337 int i, pred_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6338 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6339 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6340 mb_type |= MB_TYPE_8x8DCT; | |
6341 for( i = 0; i < 16; i+=4 ) { | |
6342 int pred = pred_intra_mode( h, i ); | |
6343 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6344 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6345 } | |
6346 } else { | |
6347 for( i = 0; i < 16; i++ ) { | |
6348 int pred = pred_intra_mode( h, i ); | |
6349 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
|
6350 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6351 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6352 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6353 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6354 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
|
6355 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
|
6356 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6357 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
|
6358 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
|
6359 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6360 h->chroma_pred_mode_table[mb_xy] = |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6361 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6362 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6363 pred_mode= check_intra_pred_mode( h, pred_mode ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6364 if( pred_mode < 0 ) return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6365 h->chroma_pred_mode= pred_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6366 } 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
|
6367 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
|
6368 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6369 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
|
6370 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
|
6371 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
|
6372 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
|
6373 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
|
6374 } |
3482 | 6375 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6376 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6377 pred_direct_motion(h, &mb_type); |
6378 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6379 for( i = 0; i < 4; i++ ) | |
6380 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6381 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6382 } | |
6383 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6384 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6385 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
|
6386 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
|
6387 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
|
6388 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
|
6389 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6390 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6391 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6392 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
|
6393 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
|
6394 for( i = 0; i < 4; i++ ) { |
2396 | 6395 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6396 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
|
6397 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
|
6398 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
|
6399 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6400 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
|
6401 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6402 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
|
6403 } |
2110 | 6404 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
|
6405 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
|
6406 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6407 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6408 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6409 |
2755 | 6410 if(dct8x8_allowed) |
6411 dct8x8_allowed = get_dct8x8_allowed(h); | |
6412 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6413 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
|
6414 for(i=0; i<4; i++){ |
2396 | 6415 if(IS_DIRECT(h->sub_mb_type[i])){ |
6416 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6417 continue; | |
6418 } | |
2110 | 6419 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
|
6420 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6421 if(IS_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
|
6422 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
|
6423 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
|
6424 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
|
6425 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
|
6426 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
|
6427 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
|
6428 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
|
6429 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
|
6430 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
|
6431 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6432 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
|
6433 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
|
6434 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
|
6435 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6436 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
|
6437 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
|
6438 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
|
6439 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
|
6440 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
|
6441 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6442 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
|
6443 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
|
6444 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
|
6445 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
|
6446 }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
|
6447 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
|
6448 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
|
6449 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6450 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
|
6451 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
|
6452 }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
|
6453 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
|
6454 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
|
6455 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6456 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
|
6457 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
|
6458 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6459 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
|
6460 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
|
6461 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
|
6462 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6463 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
|
6464 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
|
6465 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6466 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6467 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6468 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
|
6469 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
|
6470 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
|
6471 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
|
6472 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6473 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6474 } |
2396 | 6475 } else if( IS_DIRECT(mb_type) ) { |
6476 pred_direct_motion(h, &mb_type); | |
6477 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6478 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6479 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6480 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6481 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
|
6482 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
|
6483 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
|
6484 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
|
6485 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
|
6486 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
|
6487 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
|
6488 } |
2523 | 6489 }else |
6490 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
|
6491 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6492 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
|
6493 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
|
6494 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
|
6495 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6496 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
|
6497 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
|
6498 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
|
6499 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6500 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
|
6501 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6502 }else |
6503 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
|
6504 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6505 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6506 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
|
6507 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
|
6508 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
|
6509 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
|
6510 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
|
6511 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
|
6512 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6513 }else |
6514 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
|
6515 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6516 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6517 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6518 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
|
6519 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
|
6520 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
|
6521 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
|
6522 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
|
6523 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
|
6524 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
|
6525 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6526 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
|
6527 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6528 }else{ |
2396 | 6529 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6530 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
|
6531 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6532 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6533 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6534 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6535 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
|
6536 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
|
6537 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
|
6538 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
|
6539 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
|
6540 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
|
6541 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6542 }else |
6543 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
|
6544 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6545 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6546 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6547 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
|
6548 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6549 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6550 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
|
6551 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
|
6552 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
|
6553 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6554 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
|
6555 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
|
6556 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6557 }else{ |
2396 | 6558 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6559 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
|
6560 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6561 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6562 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6563 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6564 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6565 |
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
|
6566 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
|
6567 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
|
6568 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
|
6569 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6570 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6571 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
|
6572 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
|
6573 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
|
6574 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6575 |
3651 | 6576 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
|
6577 |
2755 | 6578 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6579 if( decode_cabac_mb_transform_size( h ) ) | |
6580 mb_type |= MB_TYPE_8x8DCT; | |
6581 } | |
6582 s->current_picture.mb_type[mb_xy]= mb_type; | |
6583 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6584 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6585 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
|
6586 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
|
6587 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6588 if(IS_INTERLACED(mb_type)){ |
3316 | 6589 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6590 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
|
6591 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
|
6592 }else{ |
3316 | 6593 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6594 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
|
6595 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
|
6596 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6597 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6598 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
|
6599 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6600 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
|
6601 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6602 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6603 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
|
6604 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
|
6605 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
|
6606 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
|
6607 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6608 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
|
6609 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6610 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
|
6611 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
|
6612 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6613 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
|
6614 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6615 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
|
6616 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
|
6617 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6618 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
|
6619 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
|
6620 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6621 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6622 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
|
6623 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6624 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6625 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
|
6626 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
|
6627 if( cbp & (1<<i8x8) ) { |
2755 | 6628 if( IS_8x8DCT(mb_type) ) { |
6629 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6630 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6631 return -1; |
6632 } 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
|
6633 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
|
6634 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
|
6635 //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
|
6636 //START_TIMER |
2919 | 6637 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
|
6638 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6639 //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
|
6640 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6641 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6642 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
|
6643 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6647 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6648 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
|
6649 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
|
6650 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
|
6651 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6652 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
|
6653 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
|
6654 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6655 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6656 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6657 if( cbp&0x20 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6658 int c, i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6659 for( c = 0; c < 2; c++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6660 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
|
6661 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
|
6662 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6663 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
|
6664 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
|
6665 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6666 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6667 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6668 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
|
6669 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
|
6670 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
|
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 { |
2315 | 6673 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6674 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6675 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6676 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6677 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
|
6678 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6679 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6680 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
|
6681 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
|
6682 |
3316 | 6683 if(MB_MBAFF){ |
6684 h->ref_count[0] >>= 1; | |
6685 h->ref_count[1] >>= 1; | |
6686 } | |
6687 | |
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 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
|
6689 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6690 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6691 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6692 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
|
6693 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
|
6694 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6695 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6696 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6697 |
2633 | 6698 if( bS[0] < 4 ) { |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6699 int8_t tc[4]; |
2633 | 6700 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6701 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6702 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6703 } else { | |
6704 /* 16px edge length, because bS=4 is triggered by being at | |
6705 * the edge of an intra MB, so all 4 bS are the same */ | |
6706 for( d = 0; d < 16; d++ ) { | |
1898 | 6707 const int p0 = pix[-1]; |
6708 const int p1 = pix[-2]; | |
6709 const int p2 = pix[-3]; | |
6710 | |
6711 const int q0 = pix[0]; | |
6712 const int q1 = pix[1]; | |
6713 const int q2 = pix[2]; | |
6714 | |
4001 | 6715 if( FFABS( p0 - q0 ) < alpha && |
6716 FFABS( p1 - p0 ) < beta && | |
6717 FFABS( q1 - q0 ) < beta ) { | |
6718 | |
6719 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6720 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6721 { |
6722 const int p3 = pix[-4]; | |
6723 /* p0', p1', p2' */ | |
6724 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6725 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6726 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6727 } else { | |
6728 /* p0' */ | |
6729 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6730 } | |
4001 | 6731 if( FFABS( q2 - q0 ) < beta) |
1898 | 6732 { |
6733 const int q3 = pix[3]; | |
6734 /* q0', q1', q2' */ | |
6735 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6736 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6737 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6738 } else { | |
6739 /* q0' */ | |
6740 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6741 } | |
6742 }else{ | |
6743 /* p0', q0' */ | |
6744 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6745 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6746 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6747 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
|
6748 } |
1898 | 6749 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
|
6750 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6751 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6752 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6753 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6754 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6755 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
|
6756 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
|
6757 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
|
6758 |
2633 | 6759 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
|
6760 int8_t tc[4]; |
2633 | 6761 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
|
6762 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6763 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6764 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6765 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
|
6766 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6767 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6768 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6769 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
|
6770 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6771 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
|
6772 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6773 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6774 int beta; |
2967 | 6775 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6776 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6777 int bS_index = (i >> 1); |
3316 | 6778 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6779 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6780 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6781 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6782 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6783 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6784 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6785 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6786 |
3316 | 6787 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
|
6788 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
|
6789 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
|
6790 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
|
6791 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6792 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
|
6793 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
|
6794 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6795 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6796 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6797 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6798 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6799 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6800 |
4001 | 6801 if( FFABS( p0 - q0 ) < alpha && |
6802 FFABS( p1 - p0 ) < beta && | |
6803 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6804 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6805 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6806 |
4001 | 6807 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6808 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
|
6809 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6810 } |
4001 | 6811 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6812 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
|
6813 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6814 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6815 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6816 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
|
6817 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
|
6818 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
|
6819 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
|
6820 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6821 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6822 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6823 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6824 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6825 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6826 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6827 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6829 |
4001 | 6830 if( FFABS( p0 - q0 ) < alpha && |
6831 FFABS( p1 - p0 ) < beta && | |
6832 FFABS( q1 - q0 ) < beta ) { | |
6833 | |
6834 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6835 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6836 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6837 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6838 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6839 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
|
6840 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
|
6841 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
|
6842 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6843 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6844 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
|
6845 } |
4001 | 6846 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6847 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6848 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6849 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6850 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
|
6851 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
|
6852 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
|
6853 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6854 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6855 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
|
6856 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6857 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6858 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6859 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
|
6860 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
|
6861 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6862 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
|
6863 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6864 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6865 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6866 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6867 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
|
6868 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6869 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
|
6870 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6871 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6872 int beta; |
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 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6875 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6876 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6877 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6878 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6879 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6880 |
3316 | 6881 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
|
6882 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
|
6883 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
|
6884 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6885 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6886 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
|
6887 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
|
6888 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6889 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6890 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6891 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6892 |
4001 | 6893 if( FFABS( p0 - q0 ) < alpha && |
6894 FFABS( p1 - p0 ) < beta && | |
6895 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6896 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
|
6897 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6898 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
|
6899 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
|
6900 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
|
6901 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6902 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6903 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6904 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6905 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6906 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6907 |
4001 | 6908 if( FFABS( p0 - q0 ) < alpha && |
6909 FFABS( p1 - p0 ) < beta && | |
6910 FFABS( q1 - q0 ) < beta ) { | |
2581
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 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
|
6913 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
|
6914 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
|
6915 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6916 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6917 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6918 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6919 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6920 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
|
6921 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
|
6922 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
|
6923 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
|
6924 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
|
6925 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
|
6926 |
2633 | 6927 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
|
6928 int8_t tc[4]; |
2633 | 6929 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
|
6930 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6931 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6932 } else { | |
6933 /* 16px edge length, see filter_mb_edgev */ | |
6934 for( d = 0; d < 16; d++ ) { | |
1898 | 6935 const int p0 = pix[-1*pix_next]; |
6936 const int p1 = pix[-2*pix_next]; | |
6937 const int p2 = pix[-3*pix_next]; | |
6938 const int q0 = pix[0]; | |
6939 const int q1 = pix[1*pix_next]; | |
6940 const int q2 = pix[2*pix_next]; | |
6941 | |
4001 | 6942 if( FFABS( p0 - q0 ) < alpha && |
6943 FFABS( p1 - p0 ) < beta && | |
6944 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6945 |
6946 const int p3 = pix[-4*pix_next]; | |
6947 const int q3 = pix[ 3*pix_next]; | |
6948 | |
4001 | 6949 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6950 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6951 /* p0', p1', p2' */ |
6952 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6953 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6954 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6955 } else { | |
6956 /* p0' */ | |
6957 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6958 } | |
4001 | 6959 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6960 /* q0', q1', q2' */ |
6961 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6962 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6963 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6964 } else { | |
6965 /* q0' */ | |
6966 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6967 } | |
6968 }else{ | |
6969 /* p0', q0' */ | |
6970 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6971 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6972 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6973 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
|
6974 } |
1898 | 6975 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
|
6976 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6977 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6978 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6979 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6980 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6981 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6982 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
|
6983 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
|
6984 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
|
6985 |
2633 | 6986 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
|
6987 int8_t tc[4]; |
2633 | 6988 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
|
6989 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6990 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6991 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6992 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
|
6993 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6994 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6995 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6996 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
|
6997 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6998 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6999 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7000 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7001 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
|
7002 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
|
7003 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7004 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7005 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7006 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7007 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7008 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7009 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7010 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7011 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7012 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7013 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7014 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7015 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7016 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7017 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7018 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 7019 qp_thresh = 15 - h->slice_alpha_c0_offset; |
7020 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
7021 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
7022 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7023 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7024 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7025 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7027 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7028 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7029 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7030 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7031 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7032 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7033 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7034 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7035 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7036 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7037 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7038 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7039 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7040 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7041 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7043 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7045 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7046 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7047 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7048 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7049 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7050 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7051 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7052 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7053 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7054 int edges; |
7055 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7056 edges = 4; | |
7057 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7058 } else { | |
7059 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7060 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7061 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7062 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7063 ? 3 : 0; | |
7064 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7065 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7066 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7067 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7068 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7069 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7070 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7071 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7072 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7073 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7074 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7075 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7076 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
|
7077 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7078 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
|
7079 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
|
7080 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7081 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7082 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7083 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7084 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7085 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7086 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7087 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7088 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7089 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7090 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7091 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7092 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7093 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7094 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7095 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7096 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7097 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7098 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7099 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7100 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7101 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7102 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7103 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7104 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
|
7105 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
|
7106 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7107 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7108 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
|
7109 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
|
7110 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7111 /* 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
|
7112 * 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
|
7113 * frame numbers, not indices. */ |
3316 | 7114 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7115 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
|
7116 |
3101 | 7117 //for sufficiently low qp, filtering wouldn't do anything |
7118 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7119 if(!FRAME_MBAFF){ |
3101 | 7120 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7121 int qp = s->current_picture.qscale_table[mb_xy]; | |
7122 if(qp <= qp_thresh | |
7123 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7124 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7125 return; | |
7126 } | |
7127 } | |
7128 | |
3316 | 7129 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7130 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7131 && 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
|
7132 // and current and left pair do not have the same interlaced type |
3316 | 7133 && (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
|
7134 // 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
|
7135 && (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
|
7136 /* 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
|
7137 * 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
|
7138 */ |
3316 | 7139 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7140 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
|
7141 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7142 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7143 int chroma_qp[2]; |
3316 | 7144 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
|
7145 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7146 first_vertical_edge_done = 1; |
3316 | 7147 |
7148 if( IS_INTRA(mb_type) ) | |
7149 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7150 else { | |
7151 for( i = 0; i < 8; i++ ) { | |
7152 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7153 | |
7154 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7155 bS[i] = 4; | |
7156 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7157 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7158 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7159 bS[i] = 2; | |
7160 else | |
7161 bS[i] = 1; | |
7162 } | |
7163 } | |
7164 | |
7165 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7166 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7167 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7168 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7169 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7170 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7171 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7172 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7173 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7174 | |
7175 /* Filter edge */ | |
7176 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); | |
7177 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7178 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7179 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7180 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
|
7181 } |
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
|
7182 /* 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
|
7183 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
|
7184 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7185 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7186 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7187 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7188 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7189 | |
3101 | 7190 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7191 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7192 // how often to recheck mv-based bS when iterating between edges |
7193 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7194 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7195 // how often to recheck mv-based bS when iterating along each edge | |
7196 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7197 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7198 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7199 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7200 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7201 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7202 |
2454 | 7203 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
|
7204 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
|
7205 |
3316 | 7206 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7207 && !IS_INTERLACED(mb_type) | |
7208 && IS_INTERLACED(mbm_type) | |
7209 ) { | |
7210 // This is a special case in the norm where the filtering must | |
7211 // be done twice (one each of the field) even if we are in a | |
7212 // frame macroblock. | |
7213 // | |
7214 static const int nnz_idx[4] = {4,5,6,3}; | |
7215 unsigned int tmp_linesize = 2 * linesize; | |
7216 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7217 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7218 int qp, chroma_qp; | |
7219 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7220 int16_t bS[4]; |
3316 | 7221 |
7222 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7223 if( IS_INTRA(mb_type) || | |
7224 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7225 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7226 } else { | |
7227 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7228 for( i = 0; i < 4; i++ ) { | |
7229 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7230 mbn_nnz[nnz_idx[i]] != 0 ) | |
7231 bS[i] = 2; | |
7232 else | |
7233 bS[i] = 1; | |
7234 } | |
7235 } | |
7236 // Do not use s->qscale as luma quantizer because it has not the same | |
7237 // value in IPCM macroblocks. | |
7238 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7239 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); | |
7240 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7241 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7242 chroma_qp = ( h->chroma_qp + | |
7243 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7244 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7245 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7246 } | |
7247 | |
7248 start = 1; | |
7249 } | |
7250 | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7251 /* Calculate bS */ |
2924 | 7252 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7253 /* mbn_xy: neighbor macroblock */ |
2924 | 7254 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7255 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7256 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
|
7257 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
|
7258 |
2924 | 7259 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7260 continue; |
7261 | |
2924 | 7262 if( IS_INTRA(mb_type) || |
7263 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7264 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7265 if (edge == 0) { |
2924 | 7266 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7267 || ((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
|
7268 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7269 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7270 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7271 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7272 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7273 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7274 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7275 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7276 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
|
7277 } else { |
2924 | 7278 int i, l; |
7279 int mv_done; | |
7280 | |
7281 if( edge & mask_edge ) { | |
7282 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7283 mv_done = 1; | |
7284 } | |
3316 | 7285 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7286 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7287 mv_done = 1; | |
7288 } | |
2924 | 7289 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7290 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7291 int bn_idx= b_idx - (dir ? 8:1); | |
7292 int v = 0; | |
7293 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7294 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7295 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7296 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7297 } |
7298 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7299 mv_done = 1; | |
7300 } | |
7301 else | |
7302 mv_done = 0; | |
7303 | |
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
|
7304 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
|
7305 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
|
7306 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
|
7307 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
|
7308 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
|
7309 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7310 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7311 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
|
7312 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
|
7313 } |
2924 | 7314 else if(!mv_done) |
2523 | 7315 { |
7316 bS[i] = 0; | |
7317 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
|
7318 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7319 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7320 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7321 bS[i] = 1; |
7322 break; | |
7323 } | |
7324 } | |
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 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7326 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7327 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7328 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
|
7329 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
|
7330 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7331 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7332 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7333 // 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
|
7334 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7335 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
|
7336 //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
|
7337 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
|
7338 { 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
|
7339 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
|
7340 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7341 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
|
7342 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
|
7343 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
|
7344 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
|
7345 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
|
7346 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7347 } 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
|
7348 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7349 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
|
7350 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
|
7351 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
|
7352 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
|
7353 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
|
7354 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7355 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7356 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7357 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7358 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7359 |
1168 | 7360 static int decode_slice(H264Context *h){ |
7361 MpegEncContext * const s = &h->s; | |
7362 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7363 | |
7364 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
|
7365 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7366 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
|
7367 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
|
7368 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7369 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7370 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
|
7371 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7372 /* 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
|
7373 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
|
7374 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
|
7375 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7376 ( 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
|
7377 /* calculate pre-state */ |
2755 | 7378 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
|
7379 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
|
7380 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
|
7381 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
|
7382 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7383 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
|
7384 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7385 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7386 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
|
7387 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7388 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7389 } |
7390 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7391 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7392 //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
|
7393 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
|
7394 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
|
7395 //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
|
7396 |
2163 | 7397 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
|
7398 |
3316 | 7399 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
|
7400 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
|
7401 |
2163 | 7402 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
|
7403 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7404 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
|
7405 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
|
7406 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7407 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
|
7408 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7409 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
|
7410 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
|
7411 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
|
7412 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7415 if( ++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
|
7416 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
|
7417 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7418 ++s->mb_y; |
3316 | 7419 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7420 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7421 } |
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7423 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7424 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7425 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7426 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
|
7427 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
|
7428 } |
1168 | 7429 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7430 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7431 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7432 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7433 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
|
7434 |
2163 | 7435 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
|
7436 |
3316 | 7437 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
|
7438 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
|
7439 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
|
7440 |
2163 | 7441 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
|
7442 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
|
7443 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7444 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7445 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
|
7446 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
|
7447 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
|
7448 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7449 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
|
7450 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7451 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7452 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
|
7453 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
|
7454 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
|
7455 ++s->mb_y; |
3316 | 7456 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7457 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7458 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7459 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
|
7460 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
|
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 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
|
7463 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
|
7464 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7465 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
|
7466 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7467 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
|
7468 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7469 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7473 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7474 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7475 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
|
7476 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7477 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); |
7478 | |
7479 return 0; | |
7480 }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
|
7481 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 | 7482 |
7483 return -1; | |
7484 } | |
7485 } | |
7486 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7487 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7488 |
1168 | 7489 #if 0 |
7490 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7491 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7492 int ret= decode_mb(h); | |
2967 | 7493 |
1168 | 7494 hl_decode_mb(h); |
7495 | |
7496 if(ret<0){ | |
3177 | 7497 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7498 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); |
7499 | |
7500 return -1; | |
7501 } | |
2967 | 7502 |
1168 | 7503 if(++s->mb_x >= s->mb_width){ |
7504 s->mb_x=0; | |
7505 if(++s->mb_y >= s->mb_height){ | |
7506 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7507 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); | |
7508 | |
7509 return 0; | |
7510 }else{ | |
7511 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); | |
7512 | |
7513 return -1; | |
7514 } | |
7515 } | |
7516 } | |
2967 | 7517 |
1168 | 7518 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7519 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7520 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); | |
7521 | |
7522 return 0; | |
7523 }else{ | |
7524 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); | |
7525 | |
7526 return -1; | |
7527 } | |
7528 } | |
7529 } | |
7530 s->mb_x=0; | |
7531 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7532 } | |
7533 #endif | |
7534 return -1; //not reached | |
7535 } | |
7536 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7537 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
|
7538 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7539 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7540 int e, build, i; |
2967 | 7541 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7542 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7543 return -1; |
2967 | 7544 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7545 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
|
7546 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
|
7547 } |
2967 | 7548 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7549 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7550 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
|
7551 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7552 h->x264_build= build; |
2967 | 7553 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7554 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
|
7555 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
|
7556 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7557 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7558 skip_bits(&s->gb, 8); |
2967 | 7559 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7560 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7561 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7562 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7563 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7564 MpegEncContext * const s = &h->s; |
2967 | 7565 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7566 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
|
7567 int size, type; |
2967 | 7568 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7569 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7570 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7571 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7572 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7573 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7574 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7575 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7576 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7577 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7578 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7579 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7580 case 5: |
3318 | 7581 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
|
7582 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7583 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7584 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7585 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7586 } |
2967 | 7587 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7588 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7589 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7590 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7591 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7592 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7593 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7594 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7595 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
|
7596 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7597 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7598 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
|
7599 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
|
7600 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
|
7601 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
|
7602 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
|
7603 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
|
7604 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
|
7605 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7606 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
|
7607 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
|
7608 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
|
7609 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
|
7610 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7611 |
1168 | 7612 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7613 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7614 int aspect_ratio_info_present_flag; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7615 unsigned int aspect_ratio_idc; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7616 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7617 |
7618 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7619 |
1168 | 7620 if( aspect_ratio_info_present_flag ) { |
7621 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7622 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7623 sps->sar.num= get_bits(&s->gb, 16); |
7624 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
|
7625 }else if(aspect_ratio_idc < 14){ |
1548 | 7626 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7627 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7628 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7629 return -1; |
7630 } | |
7631 }else{ | |
2967 | 7632 sps->sar.num= |
1548 | 7633 sps->sar.den= 0; |
1168 | 7634 } |
7635 // 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
|
7636 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7637 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
|
7638 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
|
7639 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7640 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7641 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
|
7642 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
|
7643 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
|
7644 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
|
7645 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
|
7646 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
|
7647 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
|
7648 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7649 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7650 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7651 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
|
7652 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
|
7653 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
|
7654 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7655 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7656 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
|
7657 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
|
7658 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
|
7659 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
|
7660 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
|
7661 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7662 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7663 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
|
7664 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
|
7665 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7666 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
|
7667 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
|
7668 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7669 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
|
7670 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
|
7671 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
|
7672 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7673 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
|
7674 if(sps->bitstream_restriction_flag){ |
4389 | 7675 unsigned int num_reorder_frames; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7676 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
|
7677 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
|
7678 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
|
7679 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
|
7680 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
4389 | 7681 num_reorder_frames= get_ue_golomb(&s->gb); |
7682 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/ | |
7683 | |
7684 if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){ | |
7685 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames); | |
7686 return -1; | |
7687 } | |
7688 | |
7689 sps->num_reorder_frames= num_reorder_frames; | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7690 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7691 |
1168 | 7692 return 0; |
7693 } | |
7694 | |
3004 | 7695 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7696 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7697 MpegEncContext * const s = &h->s; |
7698 int i, last = 8, next = 8; | |
7699 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7700 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7701 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7702 else |
7703 for(i=0;i<size;i++){ | |
7704 if(next) | |
7705 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7706 if(!i && !next){ /* matrix not written, we use the preset one */ |
7707 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7708 break; |
7709 } | |
7710 last = factors[scan[i]] = next ? next : last; | |
7711 } | |
7712 } | |
7713 | |
7714 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7715 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7716 MpegEncContext * const s = &h->s; | |
7717 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7718 const uint8_t *fallback[4] = { | |
7719 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7720 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7721 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7722 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7723 }; | |
7724 if(get_bits1(&s->gb)){ | |
7725 sps->scaling_matrix_present |= is_sps; | |
3004 | 7726 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7727 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7728 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7729 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7730 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7731 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7732 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7733 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7734 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7735 } |
7736 } else if(fallback_sps) { | |
7737 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7738 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7739 } | |
7740 } | |
7741 | |
1168 | 7742 static inline int decode_seq_parameter_set(H264Context *h){ |
7743 MpegEncContext * const s = &h->s; | |
1371 | 7744 int profile_idc, level_idc; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7745 unsigned int sps_id, tmp, mb_width, mb_height; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7746 int i; |
1168 | 7747 SPS *sps; |
2967 | 7748 |
1168 | 7749 profile_idc= get_bits(&s->gb, 8); |
1371 | 7750 get_bits1(&s->gb); //constraint_set0_flag |
7751 get_bits1(&s->gb); //constraint_set1_flag | |
7752 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7753 get_bits1(&s->gb); //constraint_set3_flag |
7754 get_bits(&s->gb, 4); // reserved | |
1168 | 7755 level_idc= get_bits(&s->gb, 8); |
7756 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7757 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7758 if (sps_id >= MAX_SPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7759 // ok it has gone out of hand, someone is sending us bad stuff. |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7760 av_log(h->s.avctx, AV_LOG_ERROR, "illegal sps_id (%d)\n", sps_id); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7761 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7762 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7763 |
1168 | 7764 sps= &h->sps_buffer[ sps_id ]; |
7765 sps->profile_idc= profile_idc; | |
7766 sps->level_idc= level_idc; | |
2312 | 7767 |
2755 | 7768 if(sps->profile_idc >= 100){ //high profile |
7769 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7770 get_bits1(&s->gb); //residual_color_transform_flag | |
7771 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7772 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7773 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7774 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7775 }else | |
7776 sps->scaling_matrix_present = 0; | |
2755 | 7777 |
1168 | 7778 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7779 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7780 |
1168 | 7781 if(sps->poc_type == 0){ //FIXME #define |
7782 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7783 } else if(sps->poc_type == 1){//FIXME #define | |
7784 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7785 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7786 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7787 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7788 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7789 if(tmp >= sizeof(sps->offset_for_ref_frame) / sizeof(sps->offset_for_ref_frame[0])){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7790 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7791 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7792 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7793 sps->poc_cycle_length= tmp; |
2967 | 7794 |
1168 | 7795 for(i=0; i<sps->poc_cycle_length; i++) |
7796 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7797 }else if(sps->poc_type != 2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7798 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7799 return -1; |
7800 } | |
7801 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7802 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7803 if(tmp > MAX_PICTURE_COUNT-2){ |
2254
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
7804 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
|
7805 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7806 sps->ref_frame_count= tmp; |
1371 | 7807 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7808 mb_width= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7809 mb_height= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7810 if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7811 avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7812 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n"); |
2422 | 7813 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7814 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7815 sps->mb_width = mb_width; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7816 sps->mb_height= mb_height; |
2422 | 7817 |
1168 | 7818 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7819 if(!sps->frame_mbs_only_flag) | |
7820 sps->mb_aff= get_bits1(&s->gb); | |
7821 else | |
7822 sps->mb_aff= 0; | |
7823 | |
7824 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7825 | |
3316 | 7826 #ifndef ALLOW_INTERLACE |
7827 if(sps->mb_aff) | |
3954 | 7828 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7829 #endif |
7830 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7831 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7832 | |
1371 | 7833 sps->crop= get_bits1(&s->gb); |
7834 if(sps->crop){ | |
7835 sps->crop_left = get_ue_golomb(&s->gb); | |
7836 sps->crop_right = get_ue_golomb(&s->gb); | |
7837 sps->crop_top = get_ue_golomb(&s->gb); | |
7838 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7839 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
|
7840 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7841 } |
7842 }else{ | |
2967 | 7843 sps->crop_left = |
7844 sps->crop_right = | |
7845 sps->crop_top = | |
1371 | 7846 sps->crop_bottom= 0; |
7847 } | |
7848 | |
1168 | 7849 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7850 if( sps->vui_parameters_present_flag ) | |
7851 decode_vui_parameters(h, sps); | |
2967 | 7852 |
1168 | 7853 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7854 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n", |
1168 | 7855 sps_id, sps->profile_idc, sps->level_idc, |
7856 sps->poc_type, | |
7857 sps->ref_frame_count, | |
7858 sps->mb_width, sps->mb_height, | |
7859 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7860 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7861 sps->crop_left, sps->crop_right, |
7862 sps->crop_top, sps->crop_bottom, | |
1168 | 7863 sps->vui_parameters_present_flag ? "VUI" : "" |
7864 ); | |
7865 } | |
7866 return 0; | |
7867 } | |
7868 | |
2755 | 7869 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7870 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7871 unsigned int tmp, pps_id= get_ue_golomb(&s->gb); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7872 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7873 |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7874 if(pps_id>=MAX_PPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7875 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7876 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7877 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7878 pps = &h->pps_buffer[pps_id]; |
2967 | 7879 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7880 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7881 if(tmp>=MAX_SPS_COUNT){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7882 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7883 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7884 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7885 pps->sps_id= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7886 |
1168 | 7887 pps->cabac= get_bits1(&s->gb); |
7888 pps->pic_order_present= get_bits1(&s->gb); | |
7889 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7890 if(pps->slice_group_count > 1 ){ | |
7891 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
|
7892 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7893 switch(pps->mb_slice_group_map_type){ |
7894 case 0: | |
7895 #if 0 | |
7896 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7897 | run_length[ i ] |1 |ue(v) | | |
7898 #endif | |
7899 break; | |
7900 case 2: | |
7901 #if 0 | |
7902 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7903 |{ | | | | |
7904 | top_left_mb[ i ] |1 |ue(v) | | |
7905 | bottom_right_mb[ i ] |1 |ue(v) | | |
7906 | } | | | | |
7907 #endif | |
7908 break; | |
7909 case 3: | |
7910 case 4: | |
7911 case 5: | |
7912 #if 0 | |
7913 | slice_group_change_direction_flag |1 |u(1) | | |
7914 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7915 #endif | |
7916 break; | |
7917 case 6: | |
7918 #if 0 | |
7919 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7920 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7921 |) | | | | |
7922 | slice_group_id[ i ] |1 |u(v) | | |
7923 #endif | |
1214 | 7924 break; |
1168 | 7925 } |
7926 } | |
7927 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7928 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
7929 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
|
7930 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7931 pps->ref_count[0]= pps->ref_count[1]= 1; |
1168 | 7932 return -1; |
7933 } | |
2967 | 7934 |
1168 | 7935 pps->weighted_pred= get_bits1(&s->gb); |
7936 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7937 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7938 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7939 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7940 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7941 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7942 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7943 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7944 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
|
7945 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7946 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7947 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7948 |
7949 if(get_bits_count(&s->gb) < bit_length){ | |
7950 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7951 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7952 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7953 } | |
2967 | 7954 |
1168 | 7955 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7956 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n", |
1168 | 7957 pps_id, pps->sps_id, |
7958 pps->cabac ? "CABAC" : "CAVLC", | |
7959 pps->slice_group_count, | |
7960 pps->ref_count[0], pps->ref_count[1], | |
7961 pps->weighted_pred ? "weighted" : "", | |
7962 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7963 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7964 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7965 pps->redundant_pic_cnt_present ? "REDU" : "", |
7966 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7967 ); |
7968 } | |
2967 | 7969 |
1168 | 7970 return 0; |
7971 } | |
7972 | |
7973 /** | |
7974 * finds the end of the current frame in the bitstream. | |
7975 * @return the position of the first byte of the next frame, or -1 | |
7976 */ | |
2392 | 7977 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7978 int i; |
1168 | 7979 uint32_t state; |
2392 | 7980 ParseContext *pc = &(h->s.parse_context); |
1168 | 7981 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7982 // mb_addr= pc->mb_addr - 1; | |
7983 state= pc->state; | |
2392 | 7984 for(i=0; i<=buf_size; i++){ |
1168 | 7985 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7986 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7987 if(pc->frame_start_found){ |
2392 | 7988 // If there isn't one more byte in the buffer |
7989 // the test on first_mb_in_slice cannot be done yet | |
7990 // do it at next call. | |
7991 if (i >= buf_size) break; | |
7992 if (buf[i] & 0x80) { | |
7993 // first_mb_in_slice is 0, probably the first nal of a new | |
7994 // slice | |
7995 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 7996 pc->state=-1; |
2392 | 7997 pc->frame_start_found= 0; |
7998 return i-4; | |
7999 } | |
1168 | 8000 } |
2392 | 8001 pc->frame_start_found = 1; |
1168 | 8002 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8003 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
|
8004 if(pc->frame_start_found){ |
2967 | 8005 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8006 pc->frame_start_found= 0; |
2967 | 8007 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8008 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8009 } |
2392 | 8010 if (i<buf_size) |
8011 state= (state<<8) | buf[i]; | |
1168 | 8012 } |
2967 | 8013 |
1168 | 8014 pc->state= state; |
1219 | 8015 return END_NOT_FOUND; |
1168 | 8016 } |
8017 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8018 #ifdef CONFIG_H264_PARSER |
1988 | 8019 static int h264_parse(AVCodecParserContext *s, |
8020 AVCodecContext *avctx, | |
2967 | 8021 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 8022 const uint8_t *buf, int buf_size) |
8023 { | |
2392 | 8024 H264Context *h = s->priv_data; |
8025 ParseContext *pc = &h->s.parse_context; | |
1988 | 8026 int next; |
2967 | 8027 |
2392 | 8028 next= find_frame_end(h, buf, buf_size); |
1988 | 8029 |
8030 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
8031 *poutbuf = NULL; | |
8032 *poutbuf_size = 0; | |
8033 return buf_size; | |
8034 } | |
8035 | |
8036 *poutbuf = (uint8_t *)buf; | |
8037 *poutbuf_size = buf_size; | |
8038 return next; | |
8039 } | |
8040 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8041 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8042 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8043 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8044 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8045 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8046 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8047 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8048 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8049 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8050 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8051 /* 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
|
8052 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8053 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
|
8054 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8055 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
|
8056 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8057 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8058 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8059 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8060 state= (state<<8) | buf[i]; |
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 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8063 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8064 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8065 |
1168 | 8066 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
8067 MpegEncContext * const s = &h->s; | |
8068 AVCodecContext * const avctx= s->avctx; | |
8069 int buf_index=0; | |
1322 | 8070 #if 0 |
1168 | 8071 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8072 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8073 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 8074 } |
8075 #endif | |
2392 | 8076 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8077 s->current_picture_ptr= NULL; |
1168 | 8078 for(;;){ |
8079 int consumed; | |
8080 int dst_length; | |
8081 int bit_length; | |
8082 uint8_t *ptr; | |
2227 | 8083 int i, nalsize = 0; |
2967 | 8084 |
2227 | 8085 if(h->is_avc) { |
8086 if(buf_index >= buf_size) break; | |
8087 nalsize = 0; | |
8088 for(i = 0; i < h->nal_length_size; i++) | |
8089 nalsize = (nalsize << 8) | buf[buf_index++]; | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8090 if(nalsize <= 1 || nalsize > buf_size){ |
3126 | 8091 if(nalsize == 1){ |
8092 buf_index++; | |
8093 continue; | |
8094 }else{ | |
8095 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8096 break; | |
8097 } | |
8098 } | |
2227 | 8099 } else { |
1168 | 8100 // start code prefix search |
8101 for(; buf_index + 3 < buf_size; buf_index++){ | |
8102 // this should allways succeed in the first iteration | |
8103 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8104 break; | |
8105 } | |
2967 | 8106 |
1168 | 8107 if(buf_index+3 >= buf_size) break; |
2967 | 8108 |
1168 | 8109 buf_index+=3; |
2967 | 8110 } |
8111 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8112 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8113 if (ptr==NULL || dst_length <= 0){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8114 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8115 } |
3341 | 8116 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8117 dst_length--; | |
1168 | 8118 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8119 | |
8120 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8121 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 | 8122 } |
2967 | 8123 |
2227 | 8124 if (h->is_avc && (nalsize != consumed)) |
8125 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8126 | |
1168 | 8127 buf_index += consumed; |
8128 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8129 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8130 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8131 continue; |
2967 | 8132 |
1168 | 8133 switch(h->nal_unit_type){ |
8134 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8135 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8136 case NAL_SLICE: |
8137 init_get_bits(&s->gb, ptr, bit_length); | |
8138 h->intra_gb_ptr= | |
8139 h->inter_gb_ptr= &s->gb; | |
8140 s->data_partitioning = 0; | |
2967 | 8141 |
2771 | 8142 if(decode_slice_header(h) < 0){ |
8143 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8144 break; | |
8145 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8146 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8147 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8148 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8149 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8150 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8151 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8152 decode_slice(h); |
8153 break; | |
8154 case NAL_DPA: | |
8155 init_get_bits(&s->gb, ptr, bit_length); | |
8156 h->intra_gb_ptr= | |
8157 h->inter_gb_ptr= NULL; | |
8158 s->data_partitioning = 1; | |
2967 | 8159 |
2771 | 8160 if(decode_slice_header(h) < 0){ |
8161 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8162 } | |
1168 | 8163 break; |
8164 case NAL_DPB: | |
8165 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8166 h->intra_gb_ptr= &h->intra_gb; | |
8167 break; | |
8168 case NAL_DPC: | |
8169 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8170 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8171 |
2967 | 8172 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning |
4354
d18568fb0187
Avoid calling decode_slice when context_initialized is not set.
reimar
parents:
4344
diff
changeset
|
8173 && s->context_initialized |
2793 | 8174 && s->hurry_up < 5 |
8175 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8176 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8177 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8178 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8179 decode_slice(h); |
8180 break; | |
8181 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8182 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
|
8183 decode_sei(h); |
1168 | 8184 break; |
8185 case NAL_SPS: | |
8186 init_get_bits(&s->gb, ptr, bit_length); | |
8187 decode_seq_parameter_set(h); | |
2967 | 8188 |
1168 | 8189 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8190 s->low_delay=1; | |
2967 | 8191 |
2538 | 8192 if(avctx->has_b_frames < 2) |
8193 avctx->has_b_frames= !s->low_delay; | |
1168 | 8194 break; |
8195 case NAL_PPS: | |
8196 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8197 |
2755 | 8198 decode_picture_parameter_set(h, bit_length); |
1168 | 8199 |
8200 break; | |
2960 | 8201 case NAL_AUD: |
8202 case NAL_END_SEQUENCE: | |
8203 case NAL_END_STREAM: | |
8204 case NAL_FILLER_DATA: | |
8205 case NAL_SPS_EXT: | |
8206 case NAL_AUXILIARY_SLICE: | |
1168 | 8207 break; |
2979 | 8208 default: |
8209 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8210 } |
8211 } | |
8212 | |
1174 | 8213 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
|
8214 |
2971 | 8215 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
|
8216 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8217 |
1168 | 8218 h->prev_frame_num_offset= h->frame_num_offset; |
8219 h->prev_frame_num= h->frame_num; | |
8220 if(s->current_picture_ptr->reference){ | |
8221 h->prev_poc_msb= h->poc_msb; | |
8222 h->prev_poc_lsb= h->poc_lsb; | |
8223 } | |
8224 if(s->current_picture_ptr->reference) | |
8225 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8226 | |
8227 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
|
8228 |
1168 | 8229 MPV_frame_end(s); |
8230 | |
8231 return buf_index; | |
8232 } | |
8233 | |
8234 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8235 * returns the number of bytes consumed for building the current frame |
1168 | 8236 */ |
8237 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8238 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8239 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8240 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8241 |
1168 | 8242 return pos; |
8243 }else{ | |
8244 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8245 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8246 | |
8247 return pos; | |
8248 } | |
8249 } | |
8250 | |
2967 | 8251 static int decode_frame(AVCodecContext *avctx, |
1168 | 8252 void *data, int *data_size, |
8253 uint8_t *buf, int buf_size) | |
8254 { | |
8255 H264Context *h = avctx->priv_data; | |
8256 MpegEncContext *s = &h->s; | |
2967 | 8257 AVFrame *pict = data; |
1168 | 8258 int buf_index; |
2967 | 8259 |
1168 | 8260 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8261 s->flags2= avctx->flags2; |
1168 | 8262 |
8263 /* no supplementary picture */ | |
8264 if (buf_size == 0) { | |
8265 return 0; | |
8266 } | |
2967 | 8267 |
1168 | 8268 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8269 int next= find_frame_end(h, buf, buf_size); |
2967 | 8270 |
1988 | 8271 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8272 return buf_size; |
8273 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8274 } | |
8275 | |
2227 | 8276 if(h->is_avc && !h->got_avcC) { |
8277 int i, cnt, nalsize; | |
8278 unsigned char *p = avctx->extradata; | |
8279 if(avctx->extradata_size < 7) { | |
8280 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8281 return -1; | |
8282 } | |
8283 if(*p != 1) { | |
8284 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8285 return -1; | |
8286 } | |
8287 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8288 so put a fake nal_length_size = 2 while parsing them */ | |
8289 h->nal_length_size = 2; | |
8290 // Decode sps from avcC | |
8291 cnt = *(p+5) & 0x1f; // Number of sps | |
8292 p += 6; | |
8293 for (i = 0; i < cnt; i++) { | |
4364 | 8294 nalsize = AV_RB16(p) + 2; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8295 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8296 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8297 return -1; | |
8298 } | |
8299 p += nalsize; | |
2967 | 8300 } |
2227 | 8301 // Decode pps from avcC |
8302 cnt = *(p++); // Number of pps | |
8303 for (i = 0; i < cnt; i++) { | |
4364 | 8304 nalsize = AV_RB16(p) + 2; |
2227 | 8305 if(decode_nal_units(h, p, nalsize) != nalsize) { |
8306 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8307 return -1; | |
8308 } | |
8309 p += nalsize; | |
2967 | 8310 } |
2227 | 8311 // Now store right nal length size, that will be use to parse all other nals |
8312 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8313 // Do not reparse avcC | |
8314 h->got_avcC = 1; | |
8315 } | |
8316 | |
4507
b80c704183e9
always decode extradata when of non-avc stream (like RTSP)
gpoirier
parents:
4391
diff
changeset
|
8317 if(avctx->frame_number==0 && !h->is_avc && s->avctx->extradata_size){ |
2967 | 8318 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8319 return -1; |
8320 } | |
8321 | |
8322 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8323 if(buf_index < 0) |
1168 | 8324 return -1; |
8325 | |
2967 | 8326 //FIXME do something with unavailable reference frames |
8327 | |
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
|
8328 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8329 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8330 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8331 return -1; |
8332 } | |
8333 | |
2409 | 8334 { |
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
|
8335 Picture *out = s->current_picture_ptr; |
2561 | 8336 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8337 *data_size = sizeof(AVFrame); |
2561 | 8338 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8339 /* Sort B-frames into display order */ |
2409 | 8340 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
|
8341 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8342 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
|
8343 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8344 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
|
8345 && 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
|
8346 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
|
8347 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8348 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8349 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8350 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8351 while(h->delayed_pic[pics]) pics++; |
4388 | 8352 |
8353 assert(pics+1 < sizeof(h->delayed_pic) / sizeof(h->delayed_pic[0])); | |
8354 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8355 h->delayed_pic[pics++] = cur; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8356 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8357 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8358 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8359 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8360 for(i=0; h->delayed_pic[i]; i++) |
2649
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
8361 if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8362 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8363 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8364 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8365 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8366 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8367 if(h->delayed_pic[i]->poc < out->poc){ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8368 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8369 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8370 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8371 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8372 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8373 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8374 { } | |
8375 else if(prev && pics <= s->avctx->has_b_frames) | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8376 out = prev; |
2923 | 8377 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8378 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8379 ((!cross_idr && prev && out->poc > prev->poc + 2) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8380 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8381 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8382 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8383 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8384 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8385 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8386 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8387 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8388 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8389 if(out_of_order || pics > s->avctx->has_b_frames){ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8390 for(i=out_idx; h->delayed_pic[i]; i++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8391 h->delayed_pic[i] = h->delayed_pic[i+1]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8392 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8393 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8394 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8395 *data_size = 0; |
2561 | 8396 else |
8397 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8398 if(prev && prev != out && prev->reference == 1) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8399 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8400 h->delayed_output_pic = out; |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
8401 #endif |
2409 | 8402 |
2937 | 8403 if(out) |
8404 *pict= *(AVFrame*)out; | |
8405 else | |
8406 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8407 } | |
8408 | |
8409 assert(pict->data[0] || !*data_size); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1698
diff
changeset
|
8410 ff_print_debug_info(s, pict); |
1168 | 8411 //printf("out %d\n", (int)pict->data[0]); |
8412 #if 0 //? | |
8413 | |
8414 /* Return the Picture timestamp as the frame number */ | |
8415 /* we substract 1 because it is added on utils.c */ | |
8416 avctx->frame_number = s->picture_number - 1; | |
8417 #endif | |
8418 return get_consumed_bytes(s, buf_index, buf_size); | |
8419 } | |
8420 #if 0 | |
8421 static inline void fill_mb_avail(H264Context *h){ | |
8422 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8423 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8424 |
8425 if(s->mb_y){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8426 h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8427 h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
8428 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8429 }else{ |
8430 h->mb_avail[0]= | |
8431 h->mb_avail[1]= | |
8432 h->mb_avail[2]= 0; | |
8433 } | |
8434 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8435 h->mb_avail[4]= 1; //FIXME move out | |
8436 h->mb_avail[5]= 0; //FIXME move out | |
8437 } | |
8438 #endif | |
8439 | |
8440 #if 0 //selftest | |
8441 #define COUNT 8000 | |
8442 #define SIZE (COUNT*40) | |
8443 int main(){ | |
8444 int i; | |
8445 uint8_t temp[SIZE]; | |
8446 PutBitContext pb; | |
8447 GetBitContext gb; | |
8448 // int int_temp[10000]; | |
8449 DSPContext dsp; | |
8450 AVCodecContext avctx; | |
2967 | 8451 |
1168 | 8452 dsputil_init(&dsp, &avctx); |
8453 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8454 init_put_bits(&pb, temp, SIZE); |
1168 | 8455 printf("testing unsigned exp golomb\n"); |
8456 for(i=0; i<COUNT; i++){ | |
8457 START_TIMER | |
8458 set_ue_golomb(&pb, i); | |
8459 STOP_TIMER("set_ue_golomb"); | |
8460 } | |
8461 flush_put_bits(&pb); | |
2967 | 8462 |
1168 | 8463 init_get_bits(&gb, temp, 8*SIZE); |
8464 for(i=0; i<COUNT; i++){ | |
8465 int j, s; | |
2967 | 8466 |
1168 | 8467 s= show_bits(&gb, 24); |
2967 | 8468 |
1168 | 8469 START_TIMER |
8470 j= get_ue_golomb(&gb); | |
8471 if(j != i){ | |
8472 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8473 // return -1; | |
8474 } | |
8475 STOP_TIMER("get_ue_golomb"); | |
8476 } | |
2967 | 8477 |
8478 | |
1524 | 8479 init_put_bits(&pb, temp, SIZE); |
1168 | 8480 printf("testing signed exp golomb\n"); |
8481 for(i=0; i<COUNT; i++){ | |
8482 START_TIMER | |
8483 set_se_golomb(&pb, i - COUNT/2); | |
8484 STOP_TIMER("set_se_golomb"); | |
8485 } | |
8486 flush_put_bits(&pb); | |
2967 | 8487 |
1168 | 8488 init_get_bits(&gb, temp, 8*SIZE); |
8489 for(i=0; i<COUNT; i++){ | |
8490 int j, s; | |
2967 | 8491 |
1168 | 8492 s= show_bits(&gb, 24); |
2967 | 8493 |
1168 | 8494 START_TIMER |
8495 j= get_se_golomb(&gb); | |
8496 if(j != i - COUNT/2){ | |
8497 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8498 // return -1; | |
8499 } | |
8500 STOP_TIMER("get_se_golomb"); | |
8501 } | |
8502 | |
8503 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8504 |
1168 | 8505 DCTELEM block[16]; |
8506 uint8_t src[16], ref[16]; | |
8507 uint64_t error= 0, max_error=0; | |
8508 | |
8509 for(i=0; i<COUNT; i++){ | |
8510 int j; | |
8511 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8512 for(j=0; j<16; j++){ | |
8513 ref[j]= random()%255; | |
8514 src[j]= random()%255; | |
8515 } | |
8516 | |
8517 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8518 |
1168 | 8519 //normalize |
8520 for(j=0; j<16; j++){ | |
8521 // printf("%d ", block[j]); | |
8522 block[j]= block[j]*4; | |
8523 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8524 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8525 } | |
8526 // printf("\n"); | |
2967 | 8527 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8528 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8529 /* for(j=0; j<16; j++){ |
8530 printf("%d ", ref[j]); | |
8531 } | |
8532 printf("\n");*/ | |
2967 | 8533 |
1168 | 8534 for(j=0; j<16; j++){ |
4001 | 8535 int diff= FFABS(src[j] - ref[j]); |
2967 | 8536 |
1168 | 8537 error+= diff*diff; |
8538 max_error= FFMAX(max_error, diff); | |
8539 } | |
8540 } | |
8541 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8542 #if 0 | |
8543 printf("testing quantizer\n"); | |
8544 for(qp=0; qp<52; qp++){ | |
8545 for(i=0; i<16; i++) | |
8546 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8547 |
1168 | 8548 } |
8549 #endif | |
8550 printf("Testing NAL layer\n"); | |
2967 | 8551 |
1168 | 8552 uint8_t bitstream[COUNT]; |
8553 uint8_t nal[COUNT*2]; | |
8554 H264Context h; | |
8555 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8556 |
1168 | 8557 for(i=0; i<COUNT; i++){ |
8558 int zeros= i; | |
8559 int nal_length; | |
8560 int consumed; | |
8561 int out_length; | |
8562 uint8_t *out; | |
8563 int j; | |
2967 | 8564 |
1168 | 8565 for(j=0; j<COUNT; j++){ |
8566 bitstream[j]= (random() % 255) + 1; | |
8567 } | |
2967 | 8568 |
1168 | 8569 for(j=0; j<zeros; j++){ |
8570 int pos= random() % COUNT; | |
8571 while(bitstream[pos] == 0){ | |
8572 pos++; | |
8573 pos %= COUNT; | |
8574 } | |
8575 bitstream[pos]=0; | |
8576 } | |
2967 | 8577 |
1168 | 8578 START_TIMER |
2967 | 8579 |
1168 | 8580 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8581 if(nal_length<0){ | |
8582 printf("encoding failed\n"); | |
8583 return -1; | |
8584 } | |
2967 | 8585 |
1168 | 8586 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8587 | |
8588 STOP_TIMER("NAL") | |
2967 | 8589 |
1168 | 8590 if(out_length != COUNT){ |
8591 printf("incorrect length %d %d\n", out_length, COUNT); | |
8592 return -1; | |
8593 } | |
2967 | 8594 |
1168 | 8595 if(consumed != nal_length){ |
8596 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8597 return -1; | |
8598 } | |
2967 | 8599 |
1168 | 8600 if(memcmp(bitstream, out, COUNT)){ |
8601 printf("missmatch\n"); | |
8602 return -1; | |
8603 } | |
8604 } | |
2967 | 8605 |
1168 | 8606 printf("Testing RBSP\n"); |
2967 | 8607 |
8608 | |
1168 | 8609 return 0; |
8610 } | |
8611 #endif | |
8612 | |
8613 | |
8614 static int decode_end(AVCodecContext *avctx) | |
8615 { | |
8616 H264Context *h = avctx->priv_data; | |
8617 MpegEncContext *s = &h->s; | |
2967 | 8618 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8619 av_freep(&h->rbsp_buffer); |
1168 | 8620 free_tables(h); //FIXME cleanup init stuff perhaps |
8621 MPV_common_end(s); | |
8622 | |
8623 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8624 |
1168 | 8625 return 0; |
8626 } | |
8627 | |
8628 | |
8629 AVCodec h264_decoder = { | |
8630 "h264", | |
8631 CODEC_TYPE_VIDEO, | |
8632 CODEC_ID_H264, | |
8633 sizeof(H264Context), | |
8634 decode_init, | |
8635 NULL, | |
8636 decode_end, | |
8637 decode_frame, | |
2453 | 8638 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8639 .flush= flush_dpb, |
1168 | 8640 }; |
8641 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8642 #ifdef CONFIG_H264_PARSER |
1988 | 8643 AVCodecParser h264_parser = { |
8644 { CODEC_ID_H264 }, | |
2392 | 8645 sizeof(H264Context), |
1988 | 8646 NULL, |
8647 h264_parse, | |
8648 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8649 h264_split, |
1988 | 8650 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8651 #endif |
1988 | 8652 |
1234 | 8653 #include "svq3.c" |