Mercurial > libavcodec.hg
annotate h264.h @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 33f8308382f5 |
children | 2a9acfd46715 |
rev | line source |
---|---|
4975 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
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 | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8596
diff
changeset
|
23 * @file libavcodec/h264.h |
4975 | 24 * H.264 / AVC / MPEG4 part10 codec. |
25 * @author Michael Niedermayer <michaelni@gmx.at> | |
26 */ | |
27 | |
7760 | 28 #ifndef AVCODEC_H264_H |
29 #define AVCODEC_H264_H | |
4975 | 30 |
11203 | 31 #include "libavutil/intreadwrite.h" |
4975 | 32 #include "dsputil.h" |
33 #include "cabac.h" | |
34 #include "mpegvideo.h" | |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5231
diff
changeset
|
35 #include "h264pred.h" |
10866 | 36 #include "rectangle.h" |
4975 | 37 |
38 #define interlaced_dct interlaced_dct_is_a_bad_name | |
5129 | 39 #define mb_intra mb_intra_is_not_initialized_see_mb_type |
4975 | 40 |
41 #define LUMA_DC_BLOCK_INDEX 25 | |
42 #define CHROMA_DC_BLOCK_INDEX 26 | |
43 | |
44 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
45 #define COEFF_TOKEN_VLC_BITS 8 | |
46 #define TOTAL_ZEROS_VLC_BITS 9 | |
47 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
48 #define RUN_VLC_BITS 3 | |
49 #define RUN7_VLC_BITS 6 | |
50 | |
51 #define MAX_SPS_COUNT 32 | |
52 #define MAX_PPS_COUNT 256 | |
53 | |
54 #define MAX_MMCO_COUNT 66 | |
55 | |
7283
39e81fdd8d23
Move the size of the H264Context delayed_pic array into a #define.
astrange
parents:
7178
diff
changeset
|
56 #define MAX_DELAYED_PIC_COUNT 16 |
39e81fdd8d23
Move the size of the H264Context delayed_pic array into a #define.
astrange
parents:
7178
diff
changeset
|
57 |
4975 | 58 /* Compiling in interlaced support reduces the speed |
59 * of progressive decoding by about 2%. */ | |
60 #define ALLOW_INTERLACE | |
61 | |
7407 | 62 #define ALLOW_NOCHROMA |
63 | |
11282 | 64 #define FMO 0 |
65 | |
8079
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
66 /** |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
67 * The maximum number of slices supported by the decoder. |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
68 * must be a power of 2 |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
69 */ |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
70 #define MAX_SLICES 16 |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
71 |
4975 | 72 #ifdef ALLOW_INTERLACE |
73 #define MB_MBAFF h->mb_mbaff | |
74 #define MB_FIELD h->mb_field_decoding_flag | |
75 #define FRAME_MBAFF h->mb_aff_frame | |
5801 | 76 #define FIELD_PICTURE (s->picture_structure != PICT_FRAME) |
4975 | 77 #else |
78 #define MB_MBAFF 0 | |
79 #define MB_FIELD 0 | |
80 #define FRAME_MBAFF 0 | |
5767 | 81 #define FIELD_PICTURE 0 |
4975 | 82 #undef IS_INTERLACED |
83 #define IS_INTERLACED(mb_type) 0 | |
84 #endif | |
5781
0b3aa6f4c313
Modifies macroblock addressing and current macroblock y-position for field decoding.
andoma
parents:
5772
diff
changeset
|
85 #define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE) |
4975 | 86 |
7407 | 87 #ifdef ALLOW_NOCHROMA |
88 #define CHROMA h->sps.chroma_format_idc | |
89 #else | |
90 #define CHROMA 1 | |
91 #endif | |
92 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
93 #ifndef CABAC |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
94 #define CABAC h->pps.cabac |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
95 #endif |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
96 |
7988
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
97 #define EXTENDED_SAR 255 |
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
98 |
8207
2f35f9781c31
Move #defines that are mostly used in h264.c out of h264data.h and into h264.h.
diego
parents:
8107
diff
changeset
|
99 #define MB_TYPE_REF0 MB_TYPE_ACPRED //dirty but it fits in 16 bit |
2f35f9781c31
Move #defines that are mostly used in h264.c out of h264data.h and into h264.h.
diego
parents:
8107
diff
changeset
|
100 #define MB_TYPE_8x8DCT 0x01000000 |
2f35f9781c31
Move #defines that are mostly used in h264.c out of h264data.h and into h264.h.
diego
parents:
8107
diff
changeset
|
101 #define IS_REF0(a) ((a) & MB_TYPE_REF0) |
2f35f9781c31
Move #defines that are mostly used in h264.c out of h264data.h and into h264.h.
diego
parents:
8107
diff
changeset
|
102 #define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT) |
2f35f9781c31
Move #defines that are mostly used in h264.c out of h264data.h and into h264.h.
diego
parents:
8107
diff
changeset
|
103 |
10862
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
104 /** |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
105 * Value of Picture.reference when Picture is not a reference picture, but |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
106 * is held for delayed output. |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
107 */ |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
108 #define DELAYED_PIC_REF 4 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
109 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
110 |
7988
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
111 /* NAL unit types */ |
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
112 enum { |
7990 | 113 NAL_SLICE=1, |
114 NAL_DPA, | |
115 NAL_DPB, | |
116 NAL_DPC, | |
117 NAL_IDR_SLICE, | |
118 NAL_SEI, | |
119 NAL_SPS, | |
120 NAL_PPS, | |
121 NAL_AUD, | |
122 NAL_END_SEQUENCE, | |
123 NAL_END_STREAM, | |
124 NAL_FILLER_DATA, | |
125 NAL_SPS_EXT, | |
126 NAL_AUXILIARY_SLICE=19 | |
7988
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
127 }; |
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
128 |
4975 | 129 /** |
8762
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
130 * SEI message types |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
131 */ |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
132 typedef enum { |
8972 | 133 SEI_BUFFERING_PERIOD = 0, ///< buffering period (H.264, D.1.1) |
8762
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
134 SEI_TYPE_PIC_TIMING = 1, ///< picture timing |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
135 SEI_TYPE_USER_DATA_UNREGISTERED = 5, ///< unregistered user data |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
136 SEI_TYPE_RECOVERY_POINT = 6 ///< recovery point (frame # to decoder sync) |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
137 } SEI_Type; |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
138 |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
139 /** |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
140 * pic_struct in picture timing SEI message |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
141 */ |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
142 typedef enum { |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
143 SEI_PIC_STRUCT_FRAME = 0, ///< 0: %frame |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
144 SEI_PIC_STRUCT_TOP_FIELD = 1, ///< 1: top field |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
145 SEI_PIC_STRUCT_BOTTOM_FIELD = 2, ///< 2: bottom field |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
146 SEI_PIC_STRUCT_TOP_BOTTOM = 3, ///< 3: top field, bottom field, in that order |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
147 SEI_PIC_STRUCT_BOTTOM_TOP = 4, ///< 4: bottom field, top field, in that order |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
148 SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5, ///< 5: top field, bottom field, top field repeated, in that order |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
149 SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///< 6: bottom field, top field, bottom field repeated, in that order |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
150 SEI_PIC_STRUCT_FRAME_DOUBLING = 7, ///< 7: %frame doubling |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
151 SEI_PIC_STRUCT_FRAME_TRIPLING = 8 ///< 8: %frame tripling |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
152 } SEI_PicStructType; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
153 |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
154 /** |
4975 | 155 * Sequence parameter set |
156 */ | |
157 typedef struct SPS{ | |
158 | |
159 int profile_idc; | |
160 int level_idc; | |
7407 | 161 int chroma_format_idc; |
4975 | 162 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag |
163 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 | |
164 int poc_type; ///< pic_order_cnt_type | |
165 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
166 int delta_pic_order_always_zero_flag; | |
167 int offset_for_non_ref_pic; | |
168 int offset_for_top_to_bottom_field; | |
169 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
170 int ref_frame_count; ///< num_ref_frames | |
171 int gaps_in_frame_num_allowed_flag; | |
5755
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
172 int mb_width; ///< pic_width_in_mbs_minus1 + 1 |
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
173 int mb_height; ///< pic_height_in_map_units_minus1 + 1 |
4975 | 174 int frame_mbs_only_flag; |
175 int mb_aff; ///<mb_adaptive_frame_field_flag | |
176 int direct_8x8_inference_flag; | |
177 int crop; ///< frame_cropping_flag | |
6582
7d40da88f0c7
Crop parameters are unsigned, having them negative could be bad and lead
michael
parents:
6488
diff
changeset
|
178 unsigned int crop_left; ///< frame_cropping_rect_left_offset |
7d40da88f0c7
Crop parameters are unsigned, having them negative could be bad and lead
michael
parents:
6488
diff
changeset
|
179 unsigned int crop_right; ///< frame_cropping_rect_right_offset |
7d40da88f0c7
Crop parameters are unsigned, having them negative could be bad and lead
michael
parents:
6488
diff
changeset
|
180 unsigned int crop_top; ///< frame_cropping_rect_top_offset |
7d40da88f0c7
Crop parameters are unsigned, having them negative could be bad and lead
michael
parents:
6488
diff
changeset
|
181 unsigned int crop_bottom; ///< frame_cropping_rect_bottom_offset |
4975 | 182 int vui_parameters_present_flag; |
183 AVRational sar; | |
10837
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
184 int video_signal_type_present_flag; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
185 int full_range; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
186 int colour_description_present_flag; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
187 enum AVColorPrimaries color_primaries; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
188 enum AVColorTransferCharacteristic color_trc; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
189 enum AVColorSpace colorspace; |
4975 | 190 int timing_info_present_flag; |
191 uint32_t num_units_in_tick; | |
192 uint32_t time_scale; | |
193 int fixed_frame_rate_flag; | |
194 short offset_for_ref_frame[256]; //FIXME dyn aloc? | |
195 int bitstream_restriction_flag; | |
196 int num_reorder_frames; | |
197 int scaling_matrix_present; | |
198 uint8_t scaling_matrix4[6][16]; | |
199 uint8_t scaling_matrix8[2][64]; | |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
200 int nal_hrd_parameters_present_flag; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
201 int vcl_hrd_parameters_present_flag; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
202 int pic_struct_present_flag; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
203 int time_offset_length; |
8970 | 204 int cpb_cnt; ///< See H.264 E.1.2 |
8965 | 205 int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 +1 |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
206 int cpb_removal_delay_length; ///< cpb_removal_delay_length_minus1 + 1 |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
207 int dpb_output_delay_length; ///< dpb_output_delay_length_minus1 + 1 |
8735
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
208 int bit_depth_luma; ///< bit_depth_luma_minus8 + 8 |
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
209 int bit_depth_chroma; ///< bit_depth_chroma_minus8 + 8 |
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
210 int residual_color_transform_flag; ///< residual_colour_transform_flag |
4975 | 211 }SPS; |
212 | |
213 /** | |
214 * Picture parameter set | |
215 */ | |
216 typedef struct PPS{ | |
217 unsigned int sps_id; | |
218 int cabac; ///< entropy_coding_mode_flag | |
219 int pic_order_present; ///< pic_order_present_flag | |
220 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
221 int mb_slice_group_map_type; | |
222 unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 | |
223 int weighted_pred; ///< weighted_pred_flag | |
224 int weighted_bipred_idc; | |
225 int init_qp; ///< pic_init_qp_minus26 + 26 | |
226 int init_qs; ///< pic_init_qs_minus26 + 26 | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
227 int chroma_qp_index_offset[2]; |
4975 | 228 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag |
229 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
230 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
231 int transform_8x8_mode; ///< transform_8x8_mode_flag | |
232 uint8_t scaling_matrix4[6][16]; | |
233 uint8_t scaling_matrix8[2][64]; | |
7347
612a78c3b128
qscale has a range of 0..51 we thus do not need a 256 entry table and neither need
michael
parents:
7343
diff
changeset
|
234 uint8_t chroma_qp_table[2][64]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
235 int chroma_qp_diff; |
4975 | 236 }PPS; |
237 | |
238 /** | |
239 * Memory management control operation opcode. | |
240 */ | |
241 typedef enum MMCOOpcode{ | |
242 MMCO_END=0, | |
243 MMCO_SHORT2UNUSED, | |
244 MMCO_LONG2UNUSED, | |
245 MMCO_SHORT2LONG, | |
246 MMCO_SET_MAX_LONG, | |
247 MMCO_RESET, | |
248 MMCO_LONG, | |
249 } MMCOOpcode; | |
250 | |
251 /** | |
252 * Memory management control operation. | |
253 */ | |
254 typedef struct MMCO{ | |
255 MMCOOpcode opcode; | |
5756
db5a041fd77c
Rename MMCO stuff to prepare for h264/PAFF implementation.
andoma
parents:
5755
diff
changeset
|
256 int short_pic_num; ///< pic_num without wrapping (pic_num & max_pic_num) |
db5a041fd77c
Rename MMCO stuff to prepare for h264/PAFF implementation.
andoma
parents:
5755
diff
changeset
|
257 int long_arg; ///< index, pic_num, or num long refs depending on opcode |
4975 | 258 } MMCO; |
259 | |
260 /** | |
261 * H264Context | |
262 */ | |
263 typedef struct H264Context{ | |
264 MpegEncContext s; | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
265 int chroma_qp[2]; //QPc |
4975 | 266 |
10896
f112b4d030fa
Avoid wasting 4 cpu cycles per MB in redundantly calculating qp_thresh.
michael
parents:
10893
diff
changeset
|
267 int qp_thresh; ///< QP threshold to skip loopfilter |
f112b4d030fa
Avoid wasting 4 cpu cycles per MB in redundantly calculating qp_thresh.
michael
parents:
10893
diff
changeset
|
268 |
4975 | 269 int prev_mb_skipped; |
270 int next_mb_skipped; | |
271 | |
272 //prediction stuff | |
273 int chroma_pred_mode; | |
274 int intra16x16_pred_mode; | |
275 | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
276 int topleft_mb_xy; |
4975 | 277 int top_mb_xy; |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
278 int topright_mb_xy; |
4975 | 279 int left_mb_xy[2]; |
280 | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
281 int topleft_type; |
11012
b2fd83b26dd9
Set top & left types for deblock in fill_caches().
michael
parents:
11010
diff
changeset
|
282 int top_type; |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
283 int topright_type; |
11012
b2fd83b26dd9
Set top & left types for deblock in fill_caches().
michael
parents:
11010
diff
changeset
|
284 int left_type[2]; |
b2fd83b26dd9
Set top & left types for deblock in fill_caches().
michael
parents:
11010
diff
changeset
|
285 |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
286 const uint8_t * left_block; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
287 int topleft_partition; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
288 |
4975 | 289 int8_t intra4x4_pred_mode_cache[5*8]; |
11285 | 290 int8_t (*intra4x4_pred_mode); |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5231
diff
changeset
|
291 H264PredContext hpc; |
4975 | 292 unsigned int topleft_samples_available; |
293 unsigned int top_samples_available; | |
294 unsigned int topright_samples_available; | |
295 unsigned int left_samples_available; | |
296 uint8_t (*top_borders[2])[16+2*8]; | |
297 | |
298 /** | |
299 * non zero coeff count cache. | |
300 * is 64 if not available. | |
301 */ | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10934
diff
changeset
|
302 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache)[6*8]; |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
303 |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
304 /* |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
305 .UU.YYYY |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
306 .UU.YYYY |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
307 .vv.YYYY |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
308 .VV.YYYY |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
309 */ |
10906 | 310 uint8_t (*non_zero_count)[32]; |
4975 | 311 |
312 /** | |
313 * Motion vector cache. | |
314 */ | |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
315 DECLARE_ALIGNED_16(int16_t, mv_cache)[2][5*8][2]; |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10934
diff
changeset
|
316 DECLARE_ALIGNED_8(int8_t, ref_cache)[2][5*8]; |
4975 | 317 #define LIST_NOT_USED -1 //FIXME rename? |
318 #define PART_NOT_AVAILABLE -2 | |
319 | |
320 /** | |
321 * is 1 if the specific list MV&references are set to 0,0,-2. | |
322 */ | |
323 int mv_cache_clean[2]; | |
324 | |
325 /** | |
326 * number of neighbors (top and/or left) that used 8x8 dct | |
327 */ | |
328 int neighbor_transform_size; | |
329 | |
330 /** | |
331 * block_offset[ 0..23] for frame macroblocks | |
332 * block_offset[24..47] for field macroblocks | |
333 */ | |
334 int block_offset[2*(16+8)]; | |
335 | |
336 uint32_t *mb2b_xy; //FIXME are these 4 a good idea? | |
11282 | 337 uint32_t *mb2br_xy; |
4975 | 338 int b_stride; //FIXME use s->b4_stride |
339 | |
340 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff | |
341 int mb_uvlinesize; | |
342 | |
343 int emu_edge_width; | |
344 int emu_edge_height; | |
345 | |
346 SPS sps; ///< current sps | |
347 | |
348 /** | |
349 * current pps | |
350 */ | |
351 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? | |
352 | |
11348
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
353 uint32_t dequant4_buffer[6][52][16]; //FIXME should these be moved down? |
4975 | 354 uint32_t dequant8_buffer[2][52][64]; |
355 uint32_t (*dequant4_coeff[6])[16]; | |
356 uint32_t (*dequant8_coeff[2])[64]; | |
357 | |
358 int slice_num; | |
8079
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
359 uint16_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
4975 | 360 int slice_type; |
7338 | 361 int slice_type_nos; ///< S free slice type (SI/SP are remapped to I/P) |
4975 | 362 int slice_type_fixed; |
363 | |
364 //interlacing specific flags | |
365 int mb_aff_frame; | |
366 int mb_field_decoding_flag; | |
367 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag | |
368 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10934
diff
changeset
|
369 DECLARE_ALIGNED_8(uint16_t, sub_mb_type)[4]; |
4975 | 370 |
371 //Weighted pred stuff | |
372 int use_weight; | |
373 int use_weight_chroma; | |
374 int luma_log2_weight_denom; | |
375 int chroma_log2_weight_denom; | |
11344
65fe07cf9ee4
Note about luma/chroma_weight tables and their datatype.
michael
parents:
11341
diff
changeset
|
376 //The following 2 can be changed to int8_t but that causes 10cpu cycles speedloss |
11349 | 377 int luma_weight[48][2][2]; |
378 int chroma_weight[48][2][2][2]; | |
4975 | 379 int implicit_weight[48][48]; |
380 | |
381 int direct_spatial_mv_pred; | |
11096 | 382 int col_parity; |
383 int col_fieldoff; | |
4975 | 384 int dist_scale_factor[16]; |
7898
a33287a39a55
Make MBAFF temporal direct mode closer to the spec.
michael
parents:
7760
diff
changeset
|
385 int dist_scale_factor_field[2][32]; |
7906
5be944626072
Another try to fix temporal direct mode references.
michael
parents:
7898
diff
changeset
|
386 int map_col_to_list0[2][16+32]; |
5be944626072
Another try to fix temporal direct mode references.
michael
parents:
7898
diff
changeset
|
387 int map_col_to_list0_field[2][2][16+32]; |
4975 | 388 |
389 /** | |
390 * num_ref_idx_l0/1_active_minus1 + 1 | |
391 */ | |
392 unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode | |
393 unsigned int list_count; | |
10906 | 394 uint8_t *list_counts; ///< Array of list_count per MB specifying the slice type |
5755
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
395 Picture ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs. |
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
396 Reordered version of default_ref_list |
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
397 according to picture reordering in slice header */ |
8079
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
398 int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 |
4975 | 399 |
400 //data partitioning | |
401 GetBitContext intra_gb; | |
402 GetBitContext inter_gb; | |
403 GetBitContext *intra_gb_ptr; | |
404 GetBitContext *inter_gb_ptr; | |
405 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10934
diff
changeset
|
406 DECLARE_ALIGNED_16(DCTELEM, mb)[16*24]; |
6488 | 407 DCTELEM mb_padding[256]; ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too large or ensure that there is some unused stuff after mb |
4975 | 408 |
409 /** | |
410 * Cabac | |
411 */ | |
412 CABACContext cabac; | |
413 uint8_t cabac_state[460]; | |
414 | |
415 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ | |
416 uint16_t *cbp_table; | |
417 int cbp; | |
418 int top_cbp; | |
419 int left_cbp; | |
420 /* chroma_pred_mode for i4x4 or i16x16, else 0 */ | |
421 uint8_t *chroma_pred_mode_table; | |
422 int last_qscale_diff; | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
423 uint8_t (*mvd_table[2])[2]; |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
424 DECLARE_ALIGNED_16(uint8_t, mvd_cache)[2][5*8][2]; |
4975 | 425 uint8_t *direct_table; |
426 uint8_t direct_cache[5*8]; | |
427 | |
428 uint8_t zigzag_scan[16]; | |
429 uint8_t zigzag_scan8x8[64]; | |
430 uint8_t zigzag_scan8x8_cavlc[64]; | |
431 uint8_t field_scan[16]; | |
432 uint8_t field_scan8x8[64]; | |
433 uint8_t field_scan8x8_cavlc[64]; | |
434 const uint8_t *zigzag_scan_q0; | |
435 const uint8_t *zigzag_scan8x8_q0; | |
436 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
437 const uint8_t *field_scan_q0; | |
438 const uint8_t *field_scan8x8_q0; | |
439 const uint8_t *field_scan8x8_cavlc_q0; | |
440 | |
441 int x264_build; | |
5642 | 442 |
11348
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
443 int mb_xy; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
444 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
445 int is_complex; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
446 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
447 //deblock |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
448 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
449 int slice_alpha_c0_offset; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
450 int slice_beta_offset; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
451 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
452 //============================================================= |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
453 //Things below are not used in the MB or more inner code |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
454 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
455 int nal_ref_idc; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
456 int nal_unit_type; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
457 uint8_t *rbsp_buffer[2]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
458 unsigned int rbsp_buffer_size[2]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
459 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
460 /** |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
461 * Used to parse AVC variant of h264 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
462 */ |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
463 int is_avc; ///< this flag is != 0 if codec is avc1 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
464 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
465 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
466 SPS *sps_buffers[MAX_SPS_COUNT]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
467 PPS *pps_buffers[MAX_PPS_COUNT]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
468 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
469 int dequant_coeff_pps; ///< reinit tables when pps changes |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
470 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
471 uint16_t *slice_table_base; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
472 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
473 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
474 //POC stuff |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
475 int poc_lsb; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
476 int poc_msb; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
477 int delta_poc_bottom; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
478 int delta_poc[2]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
479 int frame_num; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
480 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
481 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
482 int frame_num_offset; ///< for POC type 2 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
483 int prev_frame_num_offset; ///< for POC type 2 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
484 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
485 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
486 /** |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
487 * frame_num for frames or 2*frame_num+1 for field pics. |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
488 */ |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
489 int curr_pic_num; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
490 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
491 /** |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
492 * max_frame_num or 2*max_frame_num for field pics. |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
493 */ |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
494 int max_pic_num; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
495 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
496 int redundant_pic_count; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
497 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
498 Picture *short_ref[32]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
499 Picture *long_ref[32]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
500 Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
501 Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size? |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
502 int outputed_poc; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
503 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
504 /** |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
505 * memory management control operations buffer. |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
506 */ |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
507 MMCO mmco[MAX_MMCO_COUNT]; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
508 int mmco_index; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
509 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
510 int long_ref_count; ///< number of actual long term references |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
511 int short_ref_count; ///< number of actual short term references |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
512 |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
513 int cabac_init_idc; |
3c624d573966
Move all context fields that are not used in the mb and block layers
michael
parents:
11346
diff
changeset
|
514 |
5642 | 515 /** |
516 * @defgroup multithreading Members for slice based multithreading | |
517 * @{ | |
518 */ | |
519 struct H264Context *thread_context[MAX_THREADS]; | |
520 | |
521 /** | |
522 * current slice number, used to initalize slice_num of each thread/context | |
523 */ | |
524 int current_slice; | |
525 | |
526 /** | |
527 * Max number of threads / contexts. | |
528 * This is equal to AVCodecContext.thread_count unless | |
529 * multithreaded decoding is impossible, in which case it is | |
530 * reduced to 1. | |
531 */ | |
532 int max_contexts; | |
533 | |
534 /** | |
535 * 1 if the single thread fallback warning has already been | |
536 * displayed, 0 otherwise. | |
537 */ | |
538 int single_decode_warning; | |
539 | |
540 int last_slice_type; | |
541 /** @} */ | |
542 | |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
543 /** |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
544 * pic_struct in picture timing SEI message |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
545 */ |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
546 SEI_PicStructType sei_pic_struct; |
8353
add1a0d65370
Do not recalculate constant part of is_complex for every MB.
michael
parents:
8207
diff
changeset
|
547 |
8783
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
548 /** |
9831
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
549 * Complement sei_pic_struct |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
550 * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames. |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
551 * However, soft telecined frames may have these values. |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
552 * This is used in an attempt to flag soft telecine progressive. |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
553 */ |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
554 int prev_interlaced_frame; |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
555 |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
556 /** |
9128
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
557 * Bit set of clock types for fields/frames in picture timing SEI message. |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
558 * For each found ct_type, appropriate bit is set (e.g., bit 1 for |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
559 * interlaced). |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
560 */ |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
561 int sei_ct_type; |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
562 |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
563 /** |
8966 | 564 * dpb_output_delay in picture timing SEI message, see H.264 C.2.2 |
565 */ | |
566 int sei_dpb_output_delay; | |
567 | |
568 /** | |
8967 | 569 * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2 |
570 */ | |
571 int sei_cpb_removal_delay; | |
572 | |
573 /** | |
8783
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
574 * recovery_frame_cnt from SEI message |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
575 * |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
576 * Set to -1 if no recovery point SEI message found or to number of frames |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
577 * before playback synchronizes. Frames having recovery point are key |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
578 * frames. |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
579 */ |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
580 int sei_recovery_frame_cnt; |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
581 |
8735
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
582 int luma_weight_flag[2]; ///< 7.4.3.2 luma_weight_lX_flag |
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
583 int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag |
8972 | 584 |
585 // Timestamp stuff | |
586 int sei_buffering_period_present; ///< Buffering period SEI flag | |
587 int initial_cpb_removal_delay[32]; ///< Initial timestamps for CPBs | |
11341
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
588 |
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
589 //SVQ3 specific fields |
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
590 int halfpel_flag; |
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
591 int thirdpel_flag; |
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
592 int unknown_svq3_flag; |
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
593 int next_slice_index; |
a26f51d0bb63
move svq3 specific fields to the end of the context
michael
parents:
11339
diff
changeset
|
594 uint32_t svq3_watermark_key; |
4975 | 595 }H264Context; |
596 | |
10859
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
597 |
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
598 extern const uint8_t ff_h264_chroma_qp[52]; |
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
599 |
11031 | 600 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
601 | |
602 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc); | |
10859
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
603 |
8996
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
604 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
605 * Decode SEI |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
606 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
607 int ff_h264_decode_sei(H264Context *h); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
608 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
609 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
610 * Decode SPS |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
611 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
612 int ff_h264_decode_seq_parameter_set(H264Context *h); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
613 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
614 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
615 * Decode PPS |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
616 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
617 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
618 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
619 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
620 * Decodes a network abstraction layer unit. |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
621 * @param consumed is the number of bytes used as input |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
622 * @param length is the length of the array |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
623 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
624 * @returns decoded bytes, might be src+1 if no escapes |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
625 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
626 const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
627 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
628 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
629 * identifies the exact end of the bitstream |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
630 * @return the length of the trailing, or 0 if damaged |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
631 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
632 int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
633 |
9380
54e650136c87
Add a ff_h264_free_context function and call it from the H.264 parser.
reimar
parents:
9128
diff
changeset
|
634 /** |
54e650136c87
Add a ff_h264_free_context function and call it from the H.264 parser.
reimar
parents:
9128
diff
changeset
|
635 * frees any data that may have been allocated in the H264 context like SPS, PPS etc. |
54e650136c87
Add a ff_h264_free_context function and call it from the H.264 parser.
reimar
parents:
9128
diff
changeset
|
636 */ |
9384
828d15d322ed
Add forgotten void return type to ff_h264_free_context
reimar
parents:
9380
diff
changeset
|
637 av_cold void ff_h264_free_context(H264Context *h); |
9380
54e650136c87
Add a ff_h264_free_context function and call it from the H.264 parser.
reimar
parents:
9128
diff
changeset
|
638 |
10829
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
639 /** |
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
640 * reconstructs bitstream slice_type. |
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
641 */ |
10987
85de0c8a19b7
Added a missing const to ff_h264_get_slice_type().
fenrir
parents:
10985
diff
changeset
|
642 int ff_h264_get_slice_type(const H264Context *h); |
10829
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
643 |
10852 | 644 /** |
645 * allocates tables. | |
646 * needs width/height | |
647 */ | |
648 int ff_h264_alloc_tables(H264Context *h); | |
649 | |
650 /** | |
10862
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
651 * fills the default_ref_list. |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
652 */ |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
653 int ff_h264_fill_default_ref_list(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
654 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
655 int ff_h264_decode_ref_pic_list_reordering(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
656 void ff_h264_fill_mbaff_ref_list(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
657 void ff_h264_remove_all_refs(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
658 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
659 /** |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
660 * Executes the reference picture marking (memory management control operations). |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
661 */ |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
662 int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
663 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
664 int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
665 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
666 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
667 /** |
10852 | 668 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. |
669 */ | |
10863
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
670 int ff_h264_check_intra4x4_pred_mode(H264Context *h); |
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
671 |
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
672 /** |
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
673 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. |
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
674 */ |
10852 | 675 int ff_h264_check_intra_pred_mode(H264Context *h, int mode); |
676 | |
677 void ff_h264_write_back_intra_pred_mode(H264Context *h); | |
678 void ff_h264_hl_decode_mb(H264Context *h); | |
679 int ff_h264_frame_start(H264Context *h); | |
680 av_cold int ff_h264_decode_init(AVCodecContext *avctx); | |
681 av_cold int ff_h264_decode_end(AVCodecContext *avctx); | |
10866 | 682 av_cold void ff_h264_decode_init_vlc(void); |
683 | |
684 /** | |
685 * decodes a macroblock | |
686 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
687 */ | |
688 int ff_h264_decode_mb_cavlc(H264Context *h); | |
10852 | 689 |
10869 | 690 /** |
691 * decodes a CABAC coded macroblock | |
692 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
693 */ | |
694 int ff_h264_decode_mb_cabac(H264Context *h); | |
695 | |
696 void ff_h264_init_cabac_states(H264Context *h); | |
697 | |
10857
b20434143fd5
Split direct mode (macro)block decoding off h264.c.
michael
parents:
10854
diff
changeset
|
698 void ff_h264_direct_dist_scale_factor(H264Context * const h); |
b20434143fd5
Split direct mode (macro)block decoding off h264.c.
michael
parents:
10854
diff
changeset
|
699 void ff_h264_direct_ref_list_init(H264Context * const h); |
b20434143fd5
Split direct mode (macro)block decoding off h264.c.
michael
parents:
10854
diff
changeset
|
700 void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type); |
b20434143fd5
Split direct mode (macro)block decoding off h264.c.
michael
parents:
10854
diff
changeset
|
701 |
10854 | 702 void ff_h264_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); |
703 void ff_h264_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); | |
704 | |
10858 | 705 /** |
706 * Reset SEI values at the beginning of the frame. | |
707 * | |
708 * @param h H.264 context. | |
709 */ | |
710 void ff_h264_reset_sei(H264Context *h); | |
711 | |
712 | |
10852 | 713 /* |
714 o-o o-o | |
715 / / / | |
716 o-o o-o | |
717 ,---' | |
718 o-o o-o | |
719 / / / | |
720 o-o o-o | |
721 */ | |
722 //This table must be here because scan8[constant] must be known at compiletime | |
723 static const uint8_t scan8[16 + 2*4]={ | |
724 4+1*8, 5+1*8, 4+2*8, 5+2*8, | |
725 6+1*8, 7+1*8, 6+2*8, 7+2*8, | |
726 4+3*8, 5+3*8, 4+4*8, 5+4*8, | |
727 6+3*8, 7+3*8, 6+4*8, 7+4*8, | |
728 1+1*8, 2+1*8, | |
729 1+2*8, 2+2*8, | |
730 1+4*8, 2+4*8, | |
731 1+5*8, 2+5*8, | |
732 }; | |
733 | |
734 static av_always_inline uint32_t pack16to32(int a, int b){ | |
735 #if HAVE_BIGENDIAN | |
736 return (b&0xFFFF) + (a<<16); | |
737 #else | |
738 return (a&0xFFFF) + (b<<16); | |
739 #endif | |
740 } | |
741 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
742 static av_always_inline uint16_t pack8to16(int a, int b){ |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
743 #if HAVE_BIGENDIAN |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
744 return (b&0xFF) + (a<<8); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
745 #else |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
746 return (a&0xFF) + (b<<8); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
747 #endif |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
748 } |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
749 |
10852 | 750 /** |
10854 | 751 * gets the chroma qp. |
752 */ | |
753 static inline int get_chroma_qp(H264Context *h, int t, int qscale){ | |
754 return h->pps.chroma_qp_table[t][qscale]; | |
755 } | |
756 | |
10866 | 757 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my); |
758 | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
759 static void fill_decode_neighbors(H264Context *h, int mb_type){ |
10866 | 760 MpegEncContext * const s = &h->s; |
761 const int mb_xy= h->mb_xy; | |
762 int topleft_xy, top_xy, topright_xy, left_xy[2]; | |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
763 static const uint8_t left_block_options[4][16]={ |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
764 {0,1,2,3,7,10,8,11,7+0*8, 7+1*8, 7+2*8, 7+3*8, 2+0*8, 2+3*8, 2+1*8, 2+2*8}, |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
765 {2,2,3,3,8,11,8,11,7+2*8, 7+2*8, 7+3*8, 7+3*8, 2+1*8, 2+2*8, 2+1*8, 2+2*8}, |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
766 {0,0,1,1,7,10,7,10,7+0*8, 7+0*8, 7+1*8, 7+1*8, 2+0*8, 2+3*8, 2+0*8, 2+3*8}, |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
767 {0,2,0,2,7,10,7,10,7+0*8, 7+2*8, 7+0*8, 7+2*8, 2+0*8, 2+3*8, 2+0*8, 2+3*8} |
10866 | 768 }; |
769 | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
770 h->topleft_partition= -1; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
771 |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
772 top_xy = mb_xy - (s->mb_stride << MB_FIELD); |
10866 | 773 |
774 /* Wow, what a mess, why didn't they simplify the interlacing & intra | |
775 * stuff, I can't imagine that these complex rules are worth it. */ | |
776 | |
777 topleft_xy = top_xy - 1; | |
778 topright_xy= top_xy + 1; | |
779 left_xy[1] = left_xy[0] = mb_xy-1; | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
780 h->left_block = left_block_options[0]; |
10866 | 781 if(FRAME_MBAFF){ |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
782 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]); |
10866 | 783 const int curr_mb_field_flag = IS_INTERLACED(mb_type); |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
784 if(s->mb_y&1){ |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
785 if (left_mb_field_flag != curr_mb_field_flag) { |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
786 left_xy[1] = left_xy[0] = mb_xy - s->mb_stride - 1; |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
787 if (curr_mb_field_flag) { |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
788 left_xy[1] += s->mb_stride; |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
789 h->left_block = left_block_options[3]; |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
790 } else { |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
791 topleft_xy += s->mb_stride; |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
792 // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
793 h->topleft_partition = 0; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
794 h->left_block = left_block_options[1]; |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
795 } |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
796 } |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
797 }else{ |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
798 if(curr_mb_field_flag){ |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
799 topleft_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy - 1]>>7)&1)-1); |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
800 topright_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy + 1]>>7)&1)-1); |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
801 top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1); |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
802 } |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
803 if (left_mb_field_flag != curr_mb_field_flag) { |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
804 if (curr_mb_field_flag) { |
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
805 left_xy[1] += s->mb_stride; |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
806 h->left_block = left_block_options[3]; |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
807 } else { |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
808 h->left_block = left_block_options[2]; |
11008
ec192d9ebac5
Optimize mb neighbor initialization for MBAFF in fill_caches().
michael
parents:
11002
diff
changeset
|
809 } |
10866 | 810 } |
811 } | |
812 } | |
813 | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
814 h->topleft_mb_xy = topleft_xy; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
815 h->top_mb_xy = top_xy; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
816 h->topright_mb_xy= topright_xy; |
10866 | 817 h->left_mb_xy[0] = left_xy[0]; |
818 h->left_mb_xy[1] = left_xy[1]; | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
819 //FIXME do we need all in the context? |
11306 | 820 |
821 h->topleft_type = s->current_picture.mb_type[topleft_xy] ; | |
822 h->top_type = s->current_picture.mb_type[top_xy] ; | |
823 h->topright_type= s->current_picture.mb_type[topright_xy]; | |
824 h->left_type[0] = s->current_picture.mb_type[left_xy[0]] ; | |
825 h->left_type[1] = s->current_picture.mb_type[left_xy[1]] ; | |
826 | |
827 if(h->slice_table[topleft_xy ] != h->slice_num) h->topleft_type = 0; | |
828 if(h->slice_table[top_xy ] != h->slice_num) h->top_type = 0; | |
829 if(h->slice_table[topright_xy] != h->slice_num) h->topright_type= 0; | |
11307
eefbe8dadcd2
Merge h->slice_table[left_xy[0/1] ] checks, 4 cpu cycles speedup
michael
parents:
11306
diff
changeset
|
830 if(h->slice_table[left_xy[0] ] != h->slice_num) h->left_type[0] = h->left_type[1] = 0; |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
831 } |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
832 |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
833 static void fill_decode_caches(H264Context *h, int mb_type){ |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
834 MpegEncContext * const s = &h->s; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
835 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
836 int topleft_type, top_type, topright_type, left_type[2]; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
837 const uint8_t * left_block= h->left_block; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
838 int i; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
839 |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
840 topleft_xy = h->topleft_mb_xy ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
841 top_xy = h->top_mb_xy ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
842 topright_xy = h->topright_mb_xy; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
843 left_xy[0] = h->left_mb_xy[0] ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
844 left_xy[1] = h->left_mb_xy[1] ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
845 topleft_type = h->topleft_type ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
846 top_type = h->top_type ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
847 topright_type= h->topright_type ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
848 left_type[0] = h->left_type[0] ; |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
849 left_type[1] = h->left_type[1] ; |
10866 | 850 |
11158
81c3f88f460f
Skiped MBs dont need the cbp stuff so skip initing that.
michael
parents:
11156
diff
changeset
|
851 if(!IS_SKIP(mb_type)){ |
10928 | 852 if(IS_INTRA(mb_type)){ |
853 int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1; | |
854 h->topleft_samples_available= | |
855 h->top_samples_available= | |
856 h->left_samples_available= 0xFFFF; | |
857 h->topright_samples_available= 0xEEEA; | |
10866 | 858 |
10928 | 859 if(!(top_type & type_mask)){ |
860 h->topleft_samples_available= 0xB3FF; | |
861 h->top_samples_available= 0x33FF; | |
862 h->topright_samples_available= 0x26EA; | |
863 } | |
864 if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){ | |
865 if(IS_INTERLACED(mb_type)){ | |
866 if(!(left_type[0] & type_mask)){ | |
867 h->topleft_samples_available&= 0xDFFF; | |
868 h->left_samples_available&= 0x5FFF; | |
869 } | |
870 if(!(left_type[1] & type_mask)){ | |
871 h->topleft_samples_available&= 0xFF5F; | |
872 h->left_samples_available&= 0xFF5F; | |
873 } | |
874 }else{ | |
11296
4709312b48d5
Remove useless check of the 2 left MBs of a pair being in the same slice.
michael
parents:
11294
diff
changeset
|
875 int left_typei = s->current_picture.mb_type[left_xy[0] + s->mb_stride]; |
4709312b48d5
Remove useless check of the 2 left MBs of a pair being in the same slice.
michael
parents:
11294
diff
changeset
|
876 |
10928 | 877 assert(left_xy[0] == left_xy[1]); |
878 if(!((left_typei & type_mask) && (left_type[0] & type_mask))){ | |
879 h->topleft_samples_available&= 0xDF5F; | |
880 h->left_samples_available&= 0x5F5F; | |
881 } | |
10866 | 882 } |
883 }else{ | |
10928 | 884 if(!(left_type[0] & type_mask)){ |
10866 | 885 h->topleft_samples_available&= 0xDF5F; |
886 h->left_samples_available&= 0x5F5F; | |
887 } | |
888 } | |
889 | |
10928 | 890 if(!(topleft_type & type_mask)) |
891 h->topleft_samples_available&= 0x7FFF; | |
10866 | 892 |
10928 | 893 if(!(topright_type & type_mask)) |
894 h->topright_samples_available&= 0xFBFF; | |
10866 | 895 |
10928 | 896 if(IS_INTRA4x4(mb_type)){ |
897 if(IS_INTRA4x4(top_type)){ | |
11286
db94c9bc5694
Reorder intra4x4_pred_mode so that we can read/write 4 values at once.
michael
parents:
11285
diff
changeset
|
898 AV_COPY32(h->intra4x4_pred_mode_cache+4+8*0, h->intra4x4_pred_mode + h->mb2br_xy[top_xy]); |
10866 | 899 }else{ |
10928 | 900 h->intra4x4_pred_mode_cache[4+8*0]= |
901 h->intra4x4_pred_mode_cache[5+8*0]= | |
902 h->intra4x4_pred_mode_cache[6+8*0]= | |
11287 | 903 h->intra4x4_pred_mode_cache[7+8*0]= 2 - 3*!(top_type & type_mask); |
10928 | 904 } |
905 for(i=0; i<2; i++){ | |
906 if(IS_INTRA4x4(left_type[i])){ | |
11285 | 907 int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[left_xy[i]]; |
11286
db94c9bc5694
Reorder intra4x4_pred_mode so that we can read/write 4 values at once.
michael
parents:
11285
diff
changeset
|
908 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= mode[6-left_block[0+2*i]]; |
db94c9bc5694
Reorder intra4x4_pred_mode so that we can read/write 4 values at once.
michael
parents:
11285
diff
changeset
|
909 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= mode[6-left_block[1+2*i]]; |
10928 | 910 }else{ |
911 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
11287 | 912 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= 2 - 3*!(left_type[i] & type_mask); |
10928 | 913 } |
10866 | 914 } |
915 } | |
916 } | |
917 | |
918 | |
919 /* | |
920 0 . T T. T T T T | |
921 1 L . .L . . . . | |
922 2 L . .L . . . . | |
923 3 . T TL . . . . | |
924 4 L . .L . . . . | |
925 5 L . .. . . . . | |
926 */ | |
927 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec) | |
928 if(top_type){ | |
11203 | 929 AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]); |
10928 | 930 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][1+1*8]; |
931 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][2+1*8]; | |
10866 | 932 |
10928 | 933 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][1+2*8]; |
934 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][2+2*8]; | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
935 }else { |
10928 | 936 h->non_zero_count_cache[1+8*0]= |
937 h->non_zero_count_cache[2+8*0]= | |
10866 | 938 |
10928 | 939 h->non_zero_count_cache[1+8*3]= |
940 h->non_zero_count_cache[2+8*3]= | |
11203 | 941 AV_WN32A(&h->non_zero_count_cache[4+8*0], CABAC && !IS_INTRA(mb_type) ? 0 : 0x40404040); |
10866 | 942 } |
943 | |
944 for (i=0; i<2; i++) { | |
945 if(left_type[i]){ | |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
946 h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+0+2*i]]; |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
947 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+1+2*i]]; |
10928 | 948 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[8+4+2*i]]; |
949 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[8+5+2*i]]; | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
950 }else{ |
10928 | 951 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
952 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
953 h->non_zero_count_cache[0+8*1 + 8*i]= | |
954 h->non_zero_count_cache[0+8*4 + 8*i]= CABAC && !IS_INTRA(mb_type) ? 0 : 64; | |
10866 | 955 } |
956 } | |
957 | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
958 if( CABAC ) { |
10866 | 959 // top_cbp |
960 if(top_type) { | |
961 h->top_cbp = h->cbp_table[top_xy]; | |
962 } else { | |
11300 | 963 h->top_cbp = IS_INTRA(mb_type) ? 0x1CF : 0x00F; |
10866 | 964 } |
965 // left_cbp | |
966 if (left_type[0]) { | |
11301
5843fc07bda0
Remove some useless operations from the code setting left_cbp.
michael
parents:
11300
diff
changeset
|
967 h->left_cbp = (h->cbp_table[left_xy[0]] & 0x1f0) |
5843fc07bda0
Remove some useless operations from the code setting left_cbp.
michael
parents:
11300
diff
changeset
|
968 | ((h->cbp_table[left_xy[0]]>>(left_block[0]&(~1)))&2) |
5843fc07bda0
Remove some useless operations from the code setting left_cbp.
michael
parents:
11300
diff
changeset
|
969 | (((h->cbp_table[left_xy[1]]>>(left_block[2]&(~1)))&2) << 2); |
10866 | 970 } else { |
11300 | 971 h->left_cbp = IS_INTRA(mb_type) ? 0x1CF : 0x00F; |
10866 | 972 } |
973 } | |
11158
81c3f88f460f
Skiped MBs dont need the cbp stuff so skip initing that.
michael
parents:
11156
diff
changeset
|
974 } |
10866 | 975 |
976 #if 1 | |
11144
0f7dcfca7b2e
Dont calculate any surrounding MVs for temporal MBs
michael
parents:
11102
diff
changeset
|
977 if(IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)){ |
10866 | 978 int list; |
979 for(list=0; list<h->list_count; list++){ | |
11145
8805efb4c3fd
Move setting MB_TYPE_L0L1 for direct MBs up, this is simpler.
michael
parents:
11144
diff
changeset
|
980 if(!USES_LIST(mb_type, list)){ |
10866 | 981 /*if(!h->mv_cache_clean[list]){ |
982 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
983 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
984 h->mv_cache_clean[list]= 1; | |
985 }*/ | |
986 continue; | |
987 } | |
11144
0f7dcfca7b2e
Dont calculate any surrounding MVs for temporal MBs
michael
parents:
11102
diff
changeset
|
988 assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)); |
0f7dcfca7b2e
Dont calculate any surrounding MVs for temporal MBs
michael
parents:
11102
diff
changeset
|
989 |
10866 | 990 h->mv_cache_clean[list]= 0; |
991 | |
992 if(USES_LIST(top_type, list)){ | |
993 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; | |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
994 AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]); |
10928 | 995 h->ref_cache[list][scan8[0] + 0 - 1*8]= |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
996 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][4*top_xy + 2]; |
10928 | 997 h->ref_cache[list][scan8[0] + 2 - 1*8]= |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
998 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][4*top_xy + 3]; |
10866 | 999 }else{ |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1000 AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]); |
11203 | 1001 AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101); |
10866 | 1002 } |
1003 | |
11334
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1004 if(mb_type & (MB_TYPE_16x8|MB_TYPE_8x8)){ |
10866 | 1005 for(i=0; i<2; i++){ |
1006 int cache_idx = scan8[0] - 1 + i*2*8; | |
1007 if(USES_LIST(left_type[i], list)){ | |
1008 const int b_xy= h->mb2b_xy[left_xy[i]] + 3; | |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1009 const int b8_xy= 4*left_xy[i] + 1; |
11203 | 1010 AV_COPY32(h->mv_cache[list][cache_idx ], s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]]); |
1011 AV_COPY32(h->mv_cache[list][cache_idx+8], s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]]); | |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1012 h->ref_cache[list][cache_idx ]= s->current_picture.ref_index[list][b8_xy + (left_block[0+i*2]&~1)]; |
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1013 h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + (left_block[1+i*2]&~1)]; |
10866 | 1014 }else{ |
11203 | 1015 AV_ZERO32(h->mv_cache [list][cache_idx ]); |
1016 AV_ZERO32(h->mv_cache [list][cache_idx+8]); | |
10866 | 1017 h->ref_cache[list][cache_idx ]= |
11019 | 1018 h->ref_cache[list][cache_idx+8]= (left_type[i]) ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
10866 | 1019 } |
1020 } | |
11334
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1021 }else{ |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1022 if(USES_LIST(left_type[0], list)){ |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1023 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1024 const int b8_xy= 4*left_xy[0] + 1; |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1025 AV_COPY32(h->mv_cache[list][scan8[0] - 1], s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]]); |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1026 h->ref_cache[list][scan8[0] - 1]= s->current_picture.ref_index[list][b8_xy + (left_block[0]&~1)]; |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1027 }else{ |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1028 AV_ZERO32(h->mv_cache [list][scan8[0] - 1]); |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1029 h->ref_cache[list][scan8[0] - 1]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1030 } |
e0428148bcf7
Load the whole left side of mv&ref only when needed.
michael
parents:
11307
diff
changeset
|
1031 } |
10866 | 1032 |
1033 if(USES_LIST(topright_type, list)){ | |
1034 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride; | |
11203 | 1035 AV_COPY32(h->mv_cache[list][scan8[0] + 4 - 1*8], s->current_picture.motion_val[list][b_xy]); |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1036 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][4*topright_xy + 2]; |
10866 | 1037 }else{ |
11203 | 1038 AV_ZERO32(h->mv_cache [list][scan8[0] + 4 - 1*8]); |
10866 | 1039 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
1040 } | |
11302
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1041 if(h->ref_cache[list][scan8[0] + 4 - 1*8] < 0){ |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1042 if(USES_LIST(topleft_type, list)){ |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1043 const int b_xy = h->mb2b_xy [topleft_xy] + 3 + h->b_stride + (h->topleft_partition & 2*h->b_stride); |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1044 const int b8_xy= 4*topleft_xy + 1 + (h->topleft_partition & 2); |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1045 AV_COPY32(h->mv_cache[list][scan8[0] - 1 - 1*8], s->current_picture.motion_val[list][b_xy]); |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1046 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy]; |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1047 }else{ |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1048 AV_ZERO32(h->mv_cache[list][scan8[0] - 1 - 1*8]); |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1049 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1050 } |
090fcf7610e8
Only load the topleft mv/ref when the topright is unavailable.
michael
parents:
11301
diff
changeset
|
1051 } |
10866 | 1052 |
11159 | 1053 if((mb_type&(MB_TYPE_SKIP|MB_TYPE_DIRECT2)) && !FRAME_MBAFF) |
10866 | 1054 continue; |
1055 | |
11156
81ef4df2c774
Also skip direct/mvd_cache init for skiped blocks.
michael
parents:
11155
diff
changeset
|
1056 if(!(mb_type&(MB_TYPE_SKIP|MB_TYPE_DIRECT2))) { |
10866 | 1057 h->ref_cache[list][scan8[4 ]] = |
1058 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; | |
11203 | 1059 AV_ZERO32(h->mv_cache [list][scan8[4 ]]); |
1060 AV_ZERO32(h->mv_cache [list][scan8[12]]); | |
10866 | 1061 |
11155 | 1062 if( CABAC ) { |
10866 | 1063 /* XXX beurk, Load mvd */ |
1064 if(USES_LIST(top_type, list)){ | |
11283
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1065 const int b_xy= h->mb2br_xy[top_xy]; |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1066 AV_COPY64(h->mvd_cache[list][scan8[0] + 0 - 1*8], h->mvd_table[list][b_xy + 0]); |
10866 | 1067 }else{ |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1068 AV_ZERO64(h->mvd_cache[list][scan8[0] + 0 - 1*8]); |
10866 | 1069 } |
1070 if(USES_LIST(left_type[0], list)){ | |
11283
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1071 const int b_xy= h->mb2br_xy[left_xy[0]] + 6; |
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1072 AV_COPY16(h->mvd_cache[list][scan8[0] - 1 + 0*8], h->mvd_table[list][b_xy - left_block[0]]); |
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1073 AV_COPY16(h->mvd_cache[list][scan8[0] - 1 + 1*8], h->mvd_table[list][b_xy - left_block[1]]); |
10866 | 1074 }else{ |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1075 AV_ZERO16(h->mvd_cache [list][scan8[0] - 1 + 0*8]); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1076 AV_ZERO16(h->mvd_cache [list][scan8[0] - 1 + 1*8]); |
10866 | 1077 } |
1078 if(USES_LIST(left_type[1], list)){ | |
11283
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1079 const int b_xy= h->mb2br_xy[left_xy[1]] + 6; |
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1080 AV_COPY16(h->mvd_cache[list][scan8[0] - 1 + 2*8], h->mvd_table[list][b_xy - left_block[2]]); |
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1081 AV_COPY16(h->mvd_cache[list][scan8[0] - 1 + 3*8], h->mvd_table[list][b_xy - left_block[3]]); |
10866 | 1082 }else{ |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1083 AV_ZERO16(h->mvd_cache [list][scan8[0] - 1 + 2*8]); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1084 AV_ZERO16(h->mvd_cache [list][scan8[0] - 1 + 3*8]); |
10866 | 1085 } |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1086 AV_ZERO16(h->mvd_cache [list][scan8[4 ]]); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1087 AV_ZERO16(h->mvd_cache [list][scan8[12]]); |
10866 | 1088 if(h->slice_type_nos == FF_B_TYPE){ |
11167 | 1089 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, MB_TYPE_16x16>>1, 1); |
10866 | 1090 |
1091 if(IS_DIRECT(top_type)){ | |
11203 | 1092 AV_WN32A(&h->direct_cache[scan8[0] - 1*8], 0x01010101*(MB_TYPE_DIRECT2>>1)); |
10866 | 1093 }else if(IS_8X8(top_type)){ |
11288 | 1094 int b8_xy = 4*top_xy; |
1095 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy + 2]; | |
1096 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 3]; | |
10866 | 1097 }else{ |
11203 | 1098 AV_WN32A(&h->direct_cache[scan8[0] - 1*8], 0x01010101*(MB_TYPE_16x16>>1)); |
10866 | 1099 } |
1100 | |
1101 if(IS_DIRECT(left_type[0])) | |
11167 | 1102 h->direct_cache[scan8[0] - 1 + 0*8]= MB_TYPE_DIRECT2>>1; |
10866 | 1103 else if(IS_8X8(left_type[0])) |
11288 | 1104 h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[4*left_xy[0] + 1 + (left_block[0]&~1)]; |
10866 | 1105 else |
11167 | 1106 h->direct_cache[scan8[0] - 1 + 0*8]= MB_TYPE_16x16>>1; |
10866 | 1107 |
1108 if(IS_DIRECT(left_type[1])) | |
11167 | 1109 h->direct_cache[scan8[0] - 1 + 2*8]= MB_TYPE_DIRECT2>>1; |
10866 | 1110 else if(IS_8X8(left_type[1])) |
11288 | 1111 h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[4*left_xy[1] + 1 + (left_block[2]&~1)]; |
10866 | 1112 else |
11167 | 1113 h->direct_cache[scan8[0] - 1 + 2*8]= MB_TYPE_16x16>>1; |
10866 | 1114 } |
1115 } | |
11155 | 1116 } |
10866 | 1117 if(FRAME_MBAFF){ |
1118 #define MAP_MVS\ | |
1119 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
1120 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
1121 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
1122 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
1123 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
1124 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
1125 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
1126 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
1127 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
1128 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
1129 if(MB_FIELD){ | |
1130 #define MAP_F2F(idx, mb_type)\ | |
1131 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
1132 h->ref_cache[list][idx] <<= 1;\ | |
1133 h->mv_cache[list][idx][1] /= 2;\ | |
11268
e817a3c2ec2e
Replace /2 by faster >>1 as the mvd values are now all positive.
michael
parents:
11267
diff
changeset
|
1134 h->mvd_cache[list][idx][1] >>=1;\ |
10866 | 1135 } |
1136 MAP_MVS | |
1137 #undef MAP_F2F | |
1138 }else{ | |
1139 #define MAP_F2F(idx, mb_type)\ | |
1140 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
1141 h->ref_cache[list][idx] >>= 1;\ | |
1142 h->mv_cache[list][idx][1] <<= 1;\ | |
1143 h->mvd_cache[list][idx][1] <<= 1;\ | |
1144 } | |
1145 MAP_MVS | |
1146 #undef MAP_F2F | |
1147 } | |
1148 } | |
1149 } | |
1150 } | |
1151 #endif | |
1152 | |
10928 | 1153 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); |
10907 | 1154 } |
1155 | |
10910 | 1156 /** |
1157 * | |
1158 * @returns non zero if the loop filter can be skiped | |
1159 */ | |
1160 static int fill_filter_caches(H264Context *h, int mb_type){ | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1161 MpegEncContext * const s = &h->s; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1162 const int mb_xy= h->mb_xy; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1163 int top_xy, left_xy[2]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1164 int top_type, left_type[2]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1165 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1166 top_xy = mb_xy - (s->mb_stride << MB_FIELD); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1167 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1168 //FIXME deblocking could skip the intra and nnz parts. |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1169 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1170 /* Wow, what a mess, why didn't they simplify the interlacing & intra |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1171 * stuff, I can't imagine that these complex rules are worth it. */ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1172 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1173 left_xy[1] = left_xy[0] = mb_xy-1; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1174 if(FRAME_MBAFF){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1175 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1176 const int curr_mb_field_flag = IS_INTERLACED(mb_type); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1177 if(s->mb_y&1){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1178 if (left_mb_field_flag != curr_mb_field_flag) { |
11023 | 1179 left_xy[0] -= s->mb_stride; |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1180 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1181 }else{ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1182 if(curr_mb_field_flag){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1183 top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1184 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1185 if (left_mb_field_flag != curr_mb_field_flag) { |
11023 | 1186 left_xy[1] += s->mb_stride; |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1187 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1188 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1189 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1190 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1191 h->top_mb_xy = top_xy; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1192 h->left_mb_xy[0] = left_xy[0]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1193 h->left_mb_xy[1] = left_xy[1]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1194 { |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1195 //for sufficiently low qp, filtering wouldn't do anything |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1196 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1197 int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1198 int qp = s->current_picture.qscale_table[mb_xy]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1199 if(qp <= qp_thresh |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1200 && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh) |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1201 && (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1202 if(!FRAME_MBAFF) |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1203 return 1; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1204 if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh) |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1205 && (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh)) |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1206 return 1; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1207 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1208 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1209 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1210 if(h->deblocking_filter == 2){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1211 h->top_type = top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1212 h->left_type[0]= left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1213 h->left_type[1]= left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1214 }else{ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1215 h->top_type = top_type = h->slice_table[top_xy ] < 0xFFFF ? s->current_picture.mb_type[top_xy] : 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1216 h->left_type[0]= left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1217 h->left_type[1]= left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1218 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1219 if(IS_INTRA(mb_type)) |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1220 return 0; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1221 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1222 AV_COPY64(&h->non_zero_count_cache[0+8*1], &h->non_zero_count[mb_xy][ 0]); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1223 AV_COPY64(&h->non_zero_count_cache[0+8*2], &h->non_zero_count[mb_xy][ 8]); |
11203 | 1224 AV_COPY32(&h->non_zero_count_cache[0+8*5], &h->non_zero_count[mb_xy][16]); |
1225 AV_COPY32(&h->non_zero_count_cache[4+8*3], &h->non_zero_count[mb_xy][20]); | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1226 AV_COPY64(&h->non_zero_count_cache[0+8*4], &h->non_zero_count[mb_xy][24]); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1227 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1228 h->cbp= h->cbp_table[mb_xy]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1229 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1230 { |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1231 int list; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1232 for(list=0; list<h->list_count; list++){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1233 int8_t *ref; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1234 int y, b_stride; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1235 int16_t (*mv_dst)[2]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1236 int16_t (*mv_src)[2]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1237 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1238 if(!USES_LIST(mb_type, list)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1239 fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4); |
11203 | 1240 AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u); |
1241 AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u); | |
1242 AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u); | |
1243 AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u); | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1244 continue; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1245 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1246 |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1247 ref = &s->current_picture.ref_index[list][4*mb_xy]; |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1248 { |
11165 | 1249 int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); |
11203 | 1250 AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); |
1251 AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); | |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1252 ref += 2; |
11203 | 1253 AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); |
1254 AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1255 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1256 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1257 b_stride = h->b_stride; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1258 mv_dst = &h->mv_cache[list][scan8[0]]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1259 mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1260 for(y=0; y<4; y++){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1261 AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1262 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1263 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1264 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1265 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1266 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1267 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1268 /* |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1269 0 . T T. T T T T |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1270 1 L . .L . . . . |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1271 2 L . .L . . . . |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1272 3 . T TL . . . . |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1273 4 L . .L . . . . |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1274 5 L . .. . . . . |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1275 */ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1276 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec) |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1277 if(top_type){ |
11203 | 1278 AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]); |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1279 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1280 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1281 if(left_type[0]){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1282 h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][7+0*8]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1283 h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][7+1*8]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1284 h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][7+2*8]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1285 h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][7+3*8]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1286 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1287 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1288 // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1289 if(!CABAC && h->pps.transform_8x8_mode){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1290 if(IS_8x8DCT(top_type)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1291 h->non_zero_count_cache[4+8*0]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1292 h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1293 h->non_zero_count_cache[6+8*0]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1294 h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1295 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1296 if(IS_8x8DCT(left_type[0])){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1297 h->non_zero_count_cache[3+8*1]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1298 h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1299 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1300 if(IS_8x8DCT(left_type[1])){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1301 h->non_zero_count_cache[3+8*3]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1302 h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1303 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1304 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1305 if(IS_8x8DCT(mb_type)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1306 h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1307 h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp & 1; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1308 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1309 h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1310 h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1311 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1312 h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1313 h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1314 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1315 h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1316 h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1317 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1318 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1319 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1320 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1321 int list; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1322 for(list=0; list<h->list_count; list++){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1323 if(USES_LIST(top_type, list)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1324 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1325 const int b8_xy= 4*top_xy + 2; |
11165 | 1326 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1327 AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]); |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1328 h->ref_cache[list][scan8[0] + 0 - 1*8]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1329 h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1330 h->ref_cache[list][scan8[0] + 2 - 1*8]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1331 h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]]; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1332 }else{ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1333 AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]); |
11203 | 1334 AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u); |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1335 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1336 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1337 if(!IS_INTERLACED(mb_type^left_type[0])){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1338 if(USES_LIST(left_type[0], list)){ |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1339 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1340 const int b8_xy= 4*left_xy[0] + 1; |
11165 | 1341 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); |
11203 | 1342 AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]); |
1343 AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]); | |
1344 AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]); | |
1345 AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]); | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1346 h->ref_cache[list][scan8[0] - 1 + 0 ]= |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1347 h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]]; |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1348 h->ref_cache[list][scan8[0] - 1 +16 ]= |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1349 h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]]; |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1350 }else{ |
11203 | 1351 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]); |
1352 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]); | |
1353 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]); | |
1354 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]); | |
11022
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1355 h->ref_cache[list][scan8[0] - 1 + 0 ]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1356 h->ref_cache[list][scan8[0] - 1 + 8 ]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1357 h->ref_cache[list][scan8[0] - 1 + 16 ]= |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1358 h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED; |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1359 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1360 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1361 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1362 } |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1363 |
44529d4292ce
Split fill_caches() between loopfilter & decode, the 2 no longer where common
michael
parents:
11020
diff
changeset
|
1364 return 0; |
10907 | 1365 } |
1366 | |
10866 | 1367 /** |
1368 * gets the predicted intra4x4 prediction mode. | |
1369 */ | |
1370 static inline int pred_intra_mode(H264Context *h, int n){ | |
1371 const int index8= scan8[n]; | |
1372 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1373 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1374 const int min= FFMIN(left, top); | |
1375 | |
1376 tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min); | |
1377 | |
1378 if(min<0) return DC_PRED; | |
1379 else return min; | |
1380 } | |
1381 | |
1382 static inline void write_back_non_zero_count(H264Context *h){ | |
1383 const int mb_xy= h->mb_xy; | |
1384 | |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1385 AV_COPY64(&h->non_zero_count[mb_xy][ 0], &h->non_zero_count_cache[0+8*1]); |
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1386 AV_COPY64(&h->non_zero_count[mb_xy][ 8], &h->non_zero_count_cache[0+8*2]); |
11203 | 1387 AV_COPY32(&h->non_zero_count[mb_xy][16], &h->non_zero_count_cache[0+8*5]); |
1388 AV_COPY32(&h->non_zero_count[mb_xy][20], &h->non_zero_count_cache[4+8*3]); | |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1389 AV_COPY64(&h->non_zero_count[mb_xy][24], &h->non_zero_count_cache[0+8*4]); |
10866 | 1390 } |
1391 | |
1392 static inline void write_back_motion(H264Context *h, int mb_type){ | |
1393 MpegEncContext * const s = &h->s; | |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1394 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; //try mb2b(8)_xy |
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1395 const int b8_xy= 4*h->mb_xy; |
10866 | 1396 int list; |
1397 | |
1398 if(!USES_LIST(mb_type, 0)) | |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1399 fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, 2, (uint8_t)LIST_NOT_USED, 1); |
10866 | 1400 |
1401 for(list=0; list<h->list_count; list++){ | |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1402 int y, b_stride; |
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1403 int16_t (*mv_dst)[2]; |
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1404 int16_t (*mv_src)[2]; |
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1405 |
10866 | 1406 if(!USES_LIST(mb_type, list)) |
1407 continue; | |
1408 | |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1409 b_stride = h->b_stride; |
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1410 mv_dst = &s->current_picture.motion_val[list][b_xy]; |
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1411 mv_src = &h->mv_cache[list][scan8[0]]; |
10866 | 1412 for(y=0; y<4; y++){ |
11002
1c8892d7a090
H.264: Use 64-/128-bit write-combining macros for copies
astrange
parents:
10987
diff
changeset
|
1413 AV_COPY128(mv_dst + y*b_stride, mv_src + 8*y); |
10866 | 1414 } |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
1415 if( CABAC ) { |
11283
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1416 uint8_t (*mvd_dst)[2] = &h->mvd_table[list][FMO ? 8*h->mb_xy : h->mb2br_xy[h->mb_xy]]; |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11268
diff
changeset
|
1417 uint8_t (*mvd_src)[2] = &h->mvd_cache[list][scan8[0]]; |
10866 | 1418 if(IS_SKIP(mb_type)) |
11283
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1419 AV_ZERO128(mvd_dst); |
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1420 else{ |
853e93a50fe5
Cut the size of mvd_table by yet another factor of 2.
michael
parents:
11282
diff
changeset
|
1421 AV_COPY64(mvd_dst, mvd_src + 8*3); |
11284
aaca4b58880f
unroll tiny and trivial loop. Same speed but clearer.
michael
parents:
11283
diff
changeset
|
1422 AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8*0); |
aaca4b58880f
unroll tiny and trivial loop. Same speed but clearer.
michael
parents:
11283
diff
changeset
|
1423 AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8*1); |
aaca4b58880f
unroll tiny and trivial loop. Same speed but clearer.
michael
parents:
11283
diff
changeset
|
1424 AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8*2); |
10866 | 1425 } |
1426 } | |
1427 | |
1428 { | |
1429 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; | |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1430 ref_index[0+0*2]= h->ref_cache[list][scan8[0]]; |
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1431 ref_index[1+0*2]= h->ref_cache[list][scan8[4]]; |
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1432 ref_index[0+1*2]= h->ref_cache[list][scan8[8]]; |
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
11288
diff
changeset
|
1433 ref_index[1+1*2]= h->ref_cache[list][scan8[12]]; |
10866 | 1434 } |
1435 } | |
1436 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
1437 if(h->slice_type_nos == FF_B_TYPE && CABAC){ |
10866 | 1438 if(IS_8X8(mb_type)){ |
11288 | 1439 uint8_t *direct_table = &h->direct_table[4*h->mb_xy]; |
1440 direct_table[1] = h->sub_mb_type[1]>>1; | |
1441 direct_table[2] = h->sub_mb_type[2]>>1; | |
1442 direct_table[3] = h->sub_mb_type[3]>>1; | |
10866 | 1443 } |
1444 } | |
1445 } | |
1446 | |
1447 static inline int get_dct8x8_allowed(H264Context *h){ | |
1448 if(h->sps.direct_8x8_inference_flag) | |
11203 | 1449 return !(AV_RN64A(h->sub_mb_type) & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8 )*0x0001000100010001ULL)); |
10866 | 1450 else |
11203 | 1451 return !(AV_RN64A(h->sub_mb_type) & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8|MB_TYPE_DIRECT2)*0x0001000100010001ULL)); |
10866 | 1452 } |
1453 | |
1454 /** | |
1455 * decodes a P_SKIP or B_SKIP macroblock | |
1456 */ | |
1457 static void decode_mb_skip(H264Context *h){ | |
1458 MpegEncContext * const s = &h->s; | |
1459 const int mb_xy= h->mb_xy; | |
1460 int mb_type=0; | |
1461 | |
10906 | 1462 memset(h->non_zero_count[mb_xy], 0, 32); |
10866 | 1463 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui |
1464 | |
1465 if(MB_FIELD) | |
1466 mb_type|= MB_TYPE_INTERLACED; | |
1467 | |
1468 if( h->slice_type_nos == FF_B_TYPE ) | |
1469 { | |
1470 // just for fill_caches. pred_direct_motion will set the real mb_type | |
11145
8805efb4c3fd
Move setting MB_TYPE_L0L1 for direct MBs up, this is simpler.
michael
parents:
11144
diff
changeset
|
1471 mb_type|= MB_TYPE_L0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
1472 if(h->direct_spatial_mv_pred){ |
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
1473 fill_decode_neighbors(h, mb_type); |
10907 | 1474 fill_decode_caches(h, mb_type); //FIXME check what is needed and what not ... |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
1475 } |
10866 | 1476 ff_h264_pred_direct_motion(h, &mb_type); |
1477 mb_type|= MB_TYPE_SKIP; | |
1478 } | |
1479 else | |
1480 { | |
1481 int mx, my; | |
1482 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; | |
1483 | |
11183
d1a855cb0a0c
Split setting neighboring MBs from fill_decode_caches()
michael
parents:
11167
diff
changeset
|
1484 fill_decode_neighbors(h, mb_type); |
10907 | 1485 fill_decode_caches(h, mb_type); //FIXME check what is needed and what not ... |
10866 | 1486 pred_pskip_motion(h, &mx, &my); |
1487 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1488 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
1489 } | |
1490 | |
1491 write_back_motion(h, mb_type); | |
1492 s->current_picture.mb_type[mb_xy]= mb_type; | |
1493 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1494 h->slice_table[ mb_xy ]= h->slice_num; | |
1495 h->prev_mb_skipped= 1; | |
1496 } | |
1497 | |
10883
4701b9355d93
Add forgotten include of h264_mvpred.h to h264.h.
michael
parents:
10869
diff
changeset
|
1498 #include "h264_mvpred.h" //For pred_pskip_motion() |
4701b9355d93
Add forgotten include of h264_mvpred.h to h264.h.
michael
parents:
10869
diff
changeset
|
1499 |
7760 | 1500 #endif /* AVCODEC_H264_H */ |