Mercurial > libavcodec.hg
annotate h264.h @ 10952:ea8f891d997d libavcodec
H264 DXVA2 implementation
It allows VLD H264 decoding using DXVA2 (GPU assisted decoding API under
VISTA and Windows 7).
It is implemented by using AVHWAccel API. It has been tested successfully
for some time in VLC using an nvidia card on Windows 7.
To compile it, you need to have the system header dxva2api.h (either from
microsoft or using http://downloads.videolan.org/pub/videolan/testing/contrib/dxva2api.h)
The generated libavcodec.dll does not depend directly on any new lib as
the necessary objects are given by the application using FFmpeg.
author | fenrir |
---|---|
date | Wed, 20 Jan 2010 18:54:51 +0000 |
parents | 9b31065f013d |
children | 34a65026fa06 |
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 |
31 #include "dsputil.h" | |
32 #include "cabac.h" | |
33 #include "mpegvideo.h" | |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5231
diff
changeset
|
34 #include "h264pred.h" |
10866 | 35 #include "rectangle.h" |
4975 | 36 |
37 #define interlaced_dct interlaced_dct_is_a_bad_name | |
5129 | 38 #define mb_intra mb_intra_is_not_initialized_see_mb_type |
4975 | 39 |
40 #define LUMA_DC_BLOCK_INDEX 25 | |
41 #define CHROMA_DC_BLOCK_INDEX 26 | |
42 | |
43 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
44 #define COEFF_TOKEN_VLC_BITS 8 | |
45 #define TOTAL_ZEROS_VLC_BITS 9 | |
46 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
47 #define RUN_VLC_BITS 3 | |
48 #define RUN7_VLC_BITS 6 | |
49 | |
50 #define MAX_SPS_COUNT 32 | |
51 #define MAX_PPS_COUNT 256 | |
52 | |
53 #define MAX_MMCO_COUNT 66 | |
54 | |
7283
39e81fdd8d23
Move the size of the H264Context delayed_pic array into a #define.
astrange
parents:
7178
diff
changeset
|
55 #define MAX_DELAYED_PIC_COUNT 16 |
39e81fdd8d23
Move the size of the H264Context delayed_pic array into a #define.
astrange
parents:
7178
diff
changeset
|
56 |
4975 | 57 /* Compiling in interlaced support reduces the speed |
58 * of progressive decoding by about 2%. */ | |
59 #define ALLOW_INTERLACE | |
60 | |
7407 | 61 #define ALLOW_NOCHROMA |
62 | |
8079
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
63 /** |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
64 * The maximum number of slices supported by the decoder. |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
65 * must be a power of 2 |
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 #define MAX_SLICES 16 |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
68 |
4975 | 69 #ifdef ALLOW_INTERLACE |
70 #define MB_MBAFF h->mb_mbaff | |
71 #define MB_FIELD h->mb_field_decoding_flag | |
72 #define FRAME_MBAFF h->mb_aff_frame | |
5801 | 73 #define FIELD_PICTURE (s->picture_structure != PICT_FRAME) |
4975 | 74 #else |
75 #define MB_MBAFF 0 | |
76 #define MB_FIELD 0 | |
77 #define FRAME_MBAFF 0 | |
5767 | 78 #define FIELD_PICTURE 0 |
4975 | 79 #undef IS_INTERLACED |
80 #define IS_INTERLACED(mb_type) 0 | |
81 #endif | |
5781
0b3aa6f4c313
Modifies macroblock addressing and current macroblock y-position for field decoding.
andoma
parents:
5772
diff
changeset
|
82 #define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE) |
4975 | 83 |
7407 | 84 #ifdef ALLOW_NOCHROMA |
85 #define CHROMA h->sps.chroma_format_idc | |
86 #else | |
87 #define CHROMA 1 | |
88 #endif | |
89 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
90 #ifndef CABAC |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
91 #define CABAC h->pps.cabac |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
92 #endif |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
93 |
7988
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
94 #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
|
95 |
8207
2f35f9781c31
Move #defines that are mostly used in h264.c out of h264data.h and into h264.h.
diego
parents:
8107
diff
changeset
|
96 #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
|
97 #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
|
98 #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
|
99 #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
|
100 |
10862
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
101 /** |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
102 * 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
|
103 * is held for delayed output. |
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 #define DELAYED_PIC_REF 4 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
106 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
107 |
7988
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
108 /* NAL unit types */ |
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
109 enum { |
7990 | 110 NAL_SLICE=1, |
111 NAL_DPA, | |
112 NAL_DPB, | |
113 NAL_DPC, | |
114 NAL_IDR_SLICE, | |
115 NAL_SEI, | |
116 NAL_SPS, | |
117 NAL_PPS, | |
118 NAL_AUD, | |
119 NAL_END_SEQUENCE, | |
120 NAL_END_STREAM, | |
121 NAL_FILLER_DATA, | |
122 NAL_SPS_EXT, | |
123 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
|
124 }; |
a7dfe657968d
Move nal unit types enum and EXTENDED_SAR #define from h264data.h to h264.h.
michael
parents:
7906
diff
changeset
|
125 |
4975 | 126 /** |
8762
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
127 * SEI message types |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
128 */ |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
129 typedef enum { |
8972 | 130 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
|
131 SEI_TYPE_PIC_TIMING = 1, ///< picture timing |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
132 SEI_TYPE_USER_DATA_UNREGISTERED = 5, ///< unregistered user data |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
133 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
|
134 } SEI_Type; |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
135 |
4f1567ce75c4
Replace hard-coded SEI type constants with symbolic names
superdump
parents:
8740
diff
changeset
|
136 /** |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
137 * pic_struct in picture timing SEI message |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
138 */ |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
139 typedef enum { |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
140 SEI_PIC_STRUCT_FRAME = 0, ///< 0: %frame |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
141 SEI_PIC_STRUCT_TOP_FIELD = 1, ///< 1: top field |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
142 SEI_PIC_STRUCT_BOTTOM_FIELD = 2, ///< 2: bottom field |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
143 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
|
144 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
|
145 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
|
146 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
|
147 SEI_PIC_STRUCT_FRAME_DOUBLING = 7, ///< 7: %frame doubling |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
148 SEI_PIC_STRUCT_FRAME_TRIPLING = 8 ///< 8: %frame tripling |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
149 } SEI_PicStructType; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
150 |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
151 /** |
4975 | 152 * Sequence parameter set |
153 */ | |
154 typedef struct SPS{ | |
155 | |
156 int profile_idc; | |
157 int level_idc; | |
7407 | 158 int chroma_format_idc; |
4975 | 159 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag |
160 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 | |
161 int poc_type; ///< pic_order_cnt_type | |
162 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
163 int delta_pic_order_always_zero_flag; | |
164 int offset_for_non_ref_pic; | |
165 int offset_for_top_to_bottom_field; | |
166 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
167 int ref_frame_count; ///< num_ref_frames | |
168 int gaps_in_frame_num_allowed_flag; | |
5755
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
169 int mb_width; ///< pic_width_in_mbs_minus1 + 1 |
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
170 int mb_height; ///< pic_height_in_map_units_minus1 + 1 |
4975 | 171 int frame_mbs_only_flag; |
172 int mb_aff; ///<mb_adaptive_frame_field_flag | |
173 int direct_8x8_inference_flag; | |
174 int crop; ///< frame_cropping_flag | |
6582
7d40da88f0c7
Crop parameters are unsigned, having them negative could be bad and lead
michael
parents:
6488
diff
changeset
|
175 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
|
176 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
|
177 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
|
178 unsigned int crop_bottom; ///< frame_cropping_rect_bottom_offset |
4975 | 179 int vui_parameters_present_flag; |
180 AVRational sar; | |
10837
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
181 int video_signal_type_present_flag; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
182 int full_range; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
183 int colour_description_present_flag; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
184 enum AVColorPrimaries color_primaries; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
185 enum AVColorTransferCharacteristic color_trc; |
e5905bfa625d
Export fullrange flag and color information for h.264
conrad
parents:
10829
diff
changeset
|
186 enum AVColorSpace colorspace; |
4975 | 187 int timing_info_present_flag; |
188 uint32_t num_units_in_tick; | |
189 uint32_t time_scale; | |
190 int fixed_frame_rate_flag; | |
191 short offset_for_ref_frame[256]; //FIXME dyn aloc? | |
192 int bitstream_restriction_flag; | |
193 int num_reorder_frames; | |
194 int scaling_matrix_present; | |
195 uint8_t scaling_matrix4[6][16]; | |
196 uint8_t scaling_matrix8[2][64]; | |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
197 int nal_hrd_parameters_present_flag; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
198 int vcl_hrd_parameters_present_flag; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
199 int pic_struct_present_flag; |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
200 int time_offset_length; |
8970 | 201 int cpb_cnt; ///< See H.264 E.1.2 |
8965 | 202 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
|
203 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
|
204 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
|
205 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
|
206 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
|
207 int residual_color_transform_flag; ///< residual_colour_transform_flag |
4975 | 208 }SPS; |
209 | |
210 /** | |
211 * Picture parameter set | |
212 */ | |
213 typedef struct PPS{ | |
214 unsigned int sps_id; | |
215 int cabac; ///< entropy_coding_mode_flag | |
216 int pic_order_present; ///< pic_order_present_flag | |
217 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
218 int mb_slice_group_map_type; | |
219 unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 | |
220 int weighted_pred; ///< weighted_pred_flag | |
221 int weighted_bipred_idc; | |
222 int init_qp; ///< pic_init_qp_minus26 + 26 | |
223 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
|
224 int chroma_qp_index_offset[2]; |
4975 | 225 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag |
226 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
227 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
228 int transform_8x8_mode; ///< transform_8x8_mode_flag | |
229 uint8_t scaling_matrix4[6][16]; | |
230 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
|
231 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
|
232 int chroma_qp_diff; |
4975 | 233 }PPS; |
234 | |
235 /** | |
236 * Memory management control operation opcode. | |
237 */ | |
238 typedef enum MMCOOpcode{ | |
239 MMCO_END=0, | |
240 MMCO_SHORT2UNUSED, | |
241 MMCO_LONG2UNUSED, | |
242 MMCO_SHORT2LONG, | |
243 MMCO_SET_MAX_LONG, | |
244 MMCO_RESET, | |
245 MMCO_LONG, | |
246 } MMCOOpcode; | |
247 | |
248 /** | |
249 * Memory management control operation. | |
250 */ | |
251 typedef struct MMCO{ | |
252 MMCOOpcode opcode; | |
5756
db5a041fd77c
Rename MMCO stuff to prepare for h264/PAFF implementation.
andoma
parents:
5755
diff
changeset
|
253 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
|
254 int long_arg; ///< index, pic_num, or num long refs depending on opcode |
4975 | 255 } MMCO; |
256 | |
257 /** | |
258 * H264Context | |
259 */ | |
260 typedef struct H264Context{ | |
261 MpegEncContext s; | |
262 int nal_ref_idc; | |
263 int nal_unit_type; | |
5174 | 264 uint8_t *rbsp_buffer[2]; |
265 unsigned int rbsp_buffer_size[2]; | |
4975 | 266 |
267 /** | |
268 * Used to parse AVC variant of h264 | |
269 */ | |
270 int is_avc; ///< this flag is != 0 if codec is avc1 | |
271 int got_avcC; ///< flag used to parse avcC data only once | |
272 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
273 | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
274 int chroma_qp[2]; //QPc |
4975 | 275 |
10896
f112b4d030fa
Avoid wasting 4 cpu cycles per MB in redundantly calculating qp_thresh.
michael
parents:
10893
diff
changeset
|
276 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
|
277 |
4975 | 278 int prev_mb_skipped; |
279 int next_mb_skipped; | |
280 | |
281 //prediction stuff | |
282 int chroma_pred_mode; | |
283 int intra16x16_pred_mode; | |
284 | |
285 int top_mb_xy; | |
286 int left_mb_xy[2]; | |
287 | |
288 int8_t intra4x4_pred_mode_cache[5*8]; | |
289 int8_t (*intra4x4_pred_mode)[8]; | |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5231
diff
changeset
|
290 H264PredContext hpc; |
4975 | 291 unsigned int topleft_samples_available; |
292 unsigned int top_samples_available; | |
293 unsigned int topright_samples_available; | |
294 unsigned int left_samples_available; | |
295 uint8_t (*top_borders[2])[16+2*8]; | |
296 uint8_t left_border[2*(17+2*9)]; | |
297 | |
298 /** | |
299 * non zero coeff count cache. | |
300 * is 64 if not available. | |
301 */ | |
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 */ | |
315 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); | |
316 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); | |
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? | |
337 uint32_t *mb2b8_xy; | |
338 int b_stride; //FIXME use s->b4_stride | |
339 int b8_stride; | |
340 | |
341 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff | |
342 int mb_uvlinesize; | |
343 | |
344 int emu_edge_width; | |
345 int emu_edge_height; | |
346 | |
347 int halfpel_flag; | |
348 int thirdpel_flag; | |
349 | |
350 int unknown_svq3_flag; | |
351 int next_slice_index; | |
352 | |
5079 | 353 SPS *sps_buffers[MAX_SPS_COUNT]; |
4975 | 354 SPS sps; ///< current sps |
355 | |
5079 | 356 PPS *pps_buffers[MAX_PPS_COUNT]; |
4975 | 357 /** |
358 * current pps | |
359 */ | |
360 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? | |
361 | |
362 uint32_t dequant4_buffer[6][52][16]; | |
363 uint32_t dequant8_buffer[2][52][64]; | |
364 uint32_t (*dequant4_coeff[6])[16]; | |
365 uint32_t (*dequant8_coeff[2])[64]; | |
366 int dequant_coeff_pps; ///< reinit tables when pps changes | |
367 | |
368 int slice_num; | |
8079
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
369 uint16_t *slice_table_base; |
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
370 uint16_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
4975 | 371 int slice_type; |
7338 | 372 int slice_type_nos; ///< S free slice type (SI/SP are remapped to I/P) |
4975 | 373 int slice_type_fixed; |
374 | |
375 //interlacing specific flags | |
376 int mb_aff_frame; | |
377 int mb_field_decoding_flag; | |
378 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag | |
379 | |
9071
24d0633a5248
sub_mb_type[] needs to be 8-byte aligned because it is referenced
stefang
parents:
8996
diff
changeset
|
380 DECLARE_ALIGNED_8(uint16_t, sub_mb_type[4]); |
4975 | 381 |
382 //POC stuff | |
383 int poc_lsb; | |
384 int poc_msb; | |
385 int delta_poc_bottom; | |
386 int delta_poc[2]; | |
387 int frame_num; | |
388 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
389 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
390 int frame_num_offset; ///< for POC type 2 | |
391 int prev_frame_num_offset; ///< for POC type 2 | |
392 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
393 | |
394 /** | |
5772
65b71bd21a4d
Fix h->curr_pic_num for field pictures. Necessary for proper PAFF support.
andoma
parents:
5767
diff
changeset
|
395 * frame_num for frames or 2*frame_num+1 for field pics. |
4975 | 396 */ |
397 int curr_pic_num; | |
398 | |
399 /** | |
400 * max_frame_num or 2*max_frame_num for field pics. | |
401 */ | |
402 int max_pic_num; | |
403 | |
404 //Weighted pred stuff | |
405 int use_weight; | |
406 int use_weight_chroma; | |
407 int luma_log2_weight_denom; | |
408 int chroma_log2_weight_denom; | |
409 int luma_weight[2][48]; | |
410 int luma_offset[2][48]; | |
411 int chroma_weight[2][48][2]; | |
412 int chroma_offset[2][48][2]; | |
413 int implicit_weight[48][48]; | |
414 | |
415 //deblock | |
416 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 | |
417 int slice_alpha_c0_offset; | |
418 int slice_beta_offset; | |
419 | |
420 int redundant_pic_count; | |
421 | |
422 int direct_spatial_mv_pred; | |
423 int dist_scale_factor[16]; | |
7898
a33287a39a55
Make MBAFF temporal direct mode closer to the spec.
michael
parents:
7760
diff
changeset
|
424 int dist_scale_factor_field[2][32]; |
7906
5be944626072
Another try to fix temporal direct mode references.
michael
parents:
7898
diff
changeset
|
425 int map_col_to_list0[2][16+32]; |
5be944626072
Another try to fix temporal direct mode references.
michael
parents:
7898
diff
changeset
|
426 int map_col_to_list0_field[2][2][16+32]; |
4975 | 427 |
428 /** | |
429 * num_ref_idx_l0/1_active_minus1 + 1 | |
430 */ | |
431 unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode | |
432 unsigned int list_count; | |
10906 | 433 uint8_t *list_counts; ///< Array of list_count per MB specifying the slice type |
4975 | 434 Picture *short_ref[32]; |
435 Picture *long_ref[32]; | |
5755
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
436 Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture |
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
437 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
|
438 Reordered version of default_ref_list |
b45894d869da
Cosmetic preparations for h264/PAFF implementation.
andoma
parents:
5642
diff
changeset
|
439 according to picture reordering in slice header */ |
8079
2d3c7cd7d143
Replace literally hardcoded max slice number by named constant.
michael
parents:
8025
diff
changeset
|
440 int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 |
7283
39e81fdd8d23
Move the size of the H264Context delayed_pic array into a #define.
astrange
parents:
7178
diff
changeset
|
441 Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size? |
7310
033d10927d45
Remove delayed_output_pic, I do not understand what this variable was good for.
michael
parents:
7283
diff
changeset
|
442 int outputed_poc; |
4975 | 443 |
444 /** | |
445 * memory management control operations buffer. | |
446 */ | |
447 MMCO mmco[MAX_MMCO_COUNT]; | |
448 int mmco_index; | |
449 | |
450 int long_ref_count; ///< number of actual long term references | |
451 int short_ref_count; ///< number of actual short term references | |
452 | |
453 //data partitioning | |
454 GetBitContext intra_gb; | |
455 GetBitContext inter_gb; | |
456 GetBitContext *intra_gb_ptr; | |
457 GetBitContext *inter_gb_ptr; | |
458 | |
6320 | 459 DECLARE_ALIGNED_16(DCTELEM, mb[16*24]); |
6488 | 460 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 | 461 |
462 /** | |
463 * Cabac | |
464 */ | |
465 CABACContext cabac; | |
466 uint8_t cabac_state[460]; | |
467 int cabac_init_idc; | |
468 | |
469 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ | |
470 uint16_t *cbp_table; | |
471 int cbp; | |
472 int top_cbp; | |
473 int left_cbp; | |
474 /* chroma_pred_mode for i4x4 or i16x16, else 0 */ | |
475 uint8_t *chroma_pred_mode_table; | |
476 int last_qscale_diff; | |
477 int16_t (*mvd_table[2])[2]; | |
478 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); | |
479 uint8_t *direct_table; | |
480 uint8_t direct_cache[5*8]; | |
481 | |
482 uint8_t zigzag_scan[16]; | |
483 uint8_t zigzag_scan8x8[64]; | |
484 uint8_t zigzag_scan8x8_cavlc[64]; | |
485 uint8_t field_scan[16]; | |
486 uint8_t field_scan8x8[64]; | |
487 uint8_t field_scan8x8_cavlc[64]; | |
488 const uint8_t *zigzag_scan_q0; | |
489 const uint8_t *zigzag_scan8x8_q0; | |
490 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
491 const uint8_t *field_scan_q0; | |
492 const uint8_t *field_scan8x8_q0; | |
493 const uint8_t *field_scan8x8_cavlc_q0; | |
494 | |
495 int x264_build; | |
5642 | 496 |
497 /** | |
498 * @defgroup multithreading Members for slice based multithreading | |
499 * @{ | |
500 */ | |
501 struct H264Context *thread_context[MAX_THREADS]; | |
502 | |
503 /** | |
504 * current slice number, used to initalize slice_num of each thread/context | |
505 */ | |
506 int current_slice; | |
507 | |
508 /** | |
509 * Max number of threads / contexts. | |
510 * This is equal to AVCodecContext.thread_count unless | |
511 * multithreaded decoding is impossible, in which case it is | |
512 * reduced to 1. | |
513 */ | |
514 int max_contexts; | |
515 | |
516 /** | |
517 * 1 if the single thread fallback warning has already been | |
518 * displayed, 0 otherwise. | |
519 */ | |
520 int single_decode_warning; | |
521 | |
522 int last_slice_type; | |
523 /** @} */ | |
524 | |
6783
df0893f4fd86
Store mb_xy in H264Context and only calculate it once per MB.
astrange
parents:
6582
diff
changeset
|
525 int mb_xy; |
df0893f4fd86
Store mb_xy in H264Context and only calculate it once per MB.
astrange
parents:
6582
diff
changeset
|
526 |
8025 | 527 uint32_t svq3_watermark_key; |
8107
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
528 |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
529 /** |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
530 * pic_struct in picture timing SEI message |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
531 */ |
e61f76efc9f3
h264: Implement decoding of picture timing SEI message.
andoma
parents:
8079
diff
changeset
|
532 SEI_PicStructType sei_pic_struct; |
8353
add1a0d65370
Do not recalculate constant part of is_complex for every MB.
michael
parents:
8207
diff
changeset
|
533 |
8783
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
534 /** |
9831
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
535 * Complement sei_pic_struct |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
536 * 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
|
537 * 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
|
538 * 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
|
539 */ |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
540 int prev_interlaced_frame; |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
541 |
febe1855b64a
Add field prev_interlaced_frame to H264Context to be able to flag soft telecine
cehoyos
parents:
9384
diff
changeset
|
542 /** |
9128
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
543 * 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
|
544 * 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
|
545 * interlaced). |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
546 */ |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
547 int sei_ct_type; |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
548 |
793cf8c68c4f
Add support for ct_type to correctly detect interlaced flag
schreter
parents:
9071
diff
changeset
|
549 /** |
8966 | 550 * dpb_output_delay in picture timing SEI message, see H.264 C.2.2 |
551 */ | |
552 int sei_dpb_output_delay; | |
553 | |
554 /** | |
8967 | 555 * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2 |
556 */ | |
557 int sei_cpb_removal_delay; | |
558 | |
559 /** | |
8783
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
560 * recovery_frame_cnt from SEI message |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
561 * |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
562 * 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
|
563 * 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
|
564 * frames. |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
565 */ |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
566 int sei_recovery_frame_cnt; |
e91ea98d868a
Add SEI recovery point frame counter to H264Context and use it when
cehoyos
parents:
8762
diff
changeset
|
567 |
8353
add1a0d65370
Do not recalculate constant part of is_complex for every MB.
michael
parents:
8207
diff
changeset
|
568 int is_complex; |
8735
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
569 |
5d7ebbb7e91b
Add fields to H264Context and SPS for upcoming VA API support.
cehoyos
parents:
8718
diff
changeset
|
570 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
|
571 int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag |
8972 | 572 |
573 // Timestamp stuff | |
574 int sei_buffering_period_present; ///< Buffering period SEI flag | |
575 int initial_cpb_removal_delay[32]; ///< Initial timestamps for CPBs | |
4975 | 576 }H264Context; |
577 | |
10859
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
578 |
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
579 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
|
580 |
762e6bb0ba40
Split (picture|seq) parameter set decoding out of h264.c.
michael
parents:
10858
diff
changeset
|
581 |
8996
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
582 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
583 * Decode SEI |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
584 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
585 int ff_h264_decode_sei(H264Context *h); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
586 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
587 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
588 * Decode SPS |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
589 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
590 int ff_h264_decode_seq_parameter_set(H264Context *h); |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
591 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
592 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
593 * Decode PPS |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
594 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
595 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
|
596 |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
597 /** |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
598 * Decodes a network abstraction layer unit. |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
599 * @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
|
600 * @param length is the length of the array |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
601 * @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
|
602 * @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
|
603 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
604 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
|
605 |
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 * identifies the exact end of the bitstream |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
608 * @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
|
609 */ |
e65778184ded
Make the following H264 functions available to the parser:
cehoyos
parents:
8972
diff
changeset
|
610 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
|
611 |
9380
54e650136c87
Add a ff_h264_free_context function and call it from the H.264 parser.
reimar
parents:
9128
diff
changeset
|
612 /** |
54e650136c87
Add a ff_h264_free_context function and call it from the H.264 parser.
reimar
parents:
9128
diff
changeset
|
613 * 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
|
614 */ |
9384
828d15d322ed
Add forgotten void return type to ff_h264_free_context
reimar
parents:
9380
diff
changeset
|
615 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
|
616 |
10829
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
617 /** |
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
618 * reconstructs bitstream slice_type. |
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
619 */ |
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
620 int ff_h264_get_slice_type(H264Context *h); |
46a247e54d6e
Export get_slice_type() as ff_h264_get_slice_type().
ramiro
parents:
9831
diff
changeset
|
621 |
10852 | 622 /** |
623 * allocates tables. | |
624 * needs width/height | |
625 */ | |
626 int ff_h264_alloc_tables(H264Context *h); | |
627 | |
628 /** | |
10862
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
629 * fills the default_ref_list. |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
630 */ |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
631 int ff_h264_fill_default_ref_list(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
632 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
633 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
|
634 void ff_h264_fill_mbaff_ref_list(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
635 void ff_h264_remove_all_refs(H264Context *h); |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
636 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
637 /** |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
638 * Executes the reference picture marking (memory management control operations). |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
639 */ |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
640 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
|
641 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
642 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
|
643 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
644 |
d9c084a0c22b
Split all the reference picture handling off h264.c.
michael
parents:
10859
diff
changeset
|
645 /** |
10852 | 646 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. |
647 */ | |
10863
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
648 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
|
649 |
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
650 /** |
974ac220c93a
Move check_intra4x4_pred_mode() back from h264.h to h264.c, the function is just
michael
parents:
10862
diff
changeset
|
651 * 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
|
652 */ |
10852 | 653 int ff_h264_check_intra_pred_mode(H264Context *h, int mode); |
654 | |
655 void ff_h264_write_back_intra_pred_mode(H264Context *h); | |
656 void ff_h264_hl_decode_mb(H264Context *h); | |
657 int ff_h264_frame_start(H264Context *h); | |
658 av_cold int ff_h264_decode_init(AVCodecContext *avctx); | |
659 av_cold int ff_h264_decode_end(AVCodecContext *avctx); | |
10866 | 660 av_cold void ff_h264_decode_init_vlc(void); |
661 | |
662 /** | |
663 * decodes a macroblock | |
664 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
665 */ | |
666 int ff_h264_decode_mb_cavlc(H264Context *h); | |
10852 | 667 |
10869 | 668 /** |
669 * decodes a CABAC coded macroblock | |
670 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
671 */ | |
672 int ff_h264_decode_mb_cabac(H264Context *h); | |
673 | |
674 void ff_h264_init_cabac_states(H264Context *h); | |
675 | |
10857
b20434143fd5
Split direct mode (macro)block decoding off h264.c.
michael
parents:
10854
diff
changeset
|
676 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
|
677 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
|
678 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
|
679 |
10854 | 680 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); |
681 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); | |
682 | |
10858 | 683 /** |
684 * Reset SEI values at the beginning of the frame. | |
685 * | |
686 * @param h H.264 context. | |
687 */ | |
688 void ff_h264_reset_sei(H264Context *h); | |
689 | |
690 | |
10852 | 691 /* |
692 o-o o-o | |
693 / / / | |
694 o-o o-o | |
695 ,---' | |
696 o-o o-o | |
697 / / / | |
698 o-o o-o | |
699 */ | |
700 //This table must be here because scan8[constant] must be known at compiletime | |
701 static const uint8_t scan8[16 + 2*4]={ | |
702 4+1*8, 5+1*8, 4+2*8, 5+2*8, | |
703 6+1*8, 7+1*8, 6+2*8, 7+2*8, | |
704 4+3*8, 5+3*8, 4+4*8, 5+4*8, | |
705 6+3*8, 7+3*8, 6+4*8, 7+4*8, | |
706 1+1*8, 2+1*8, | |
707 1+2*8, 2+2*8, | |
708 1+4*8, 2+4*8, | |
709 1+5*8, 2+5*8, | |
710 }; | |
711 | |
712 static av_always_inline uint32_t pack16to32(int a, int b){ | |
713 #if HAVE_BIGENDIAN | |
714 return (b&0xFFFF) + (a<<16); | |
715 #else | |
716 return (a&0xFFFF) + (b<<16); | |
717 #endif | |
718 } | |
719 | |
720 /** | |
10854 | 721 * gets the chroma qp. |
722 */ | |
723 static inline int get_chroma_qp(H264Context *h, int t, int qscale){ | |
724 return h->pps.chroma_qp_table[t][qscale]; | |
725 } | |
726 | |
10866 | 727 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my); |
728 | |
10910 | 729 static av_always_inline int fill_caches(H264Context *h, int mb_type, int for_deblock){ |
10866 | 730 MpegEncContext * const s = &h->s; |
731 const int mb_xy= h->mb_xy; | |
732 int topleft_xy, top_xy, topright_xy, left_xy[2]; | |
733 int topleft_type, top_type, topright_type, left_type[2]; | |
734 const uint8_t * left_block; | |
735 int topleft_partition= -1; | |
736 int i; | |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
737 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
|
738 {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
|
739 {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
|
740 {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
|
741 {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 | 742 }; |
743 | |
744 top_xy = mb_xy - (s->mb_stride << FIELD_PICTURE); | |
745 | |
746 //FIXME deblocking could skip the intra and nnz parts. | |
10906 | 747 // if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF) |
748 // return; | |
10866 | 749 |
750 /* Wow, what a mess, why didn't they simplify the interlacing & intra | |
751 * stuff, I can't imagine that these complex rules are worth it. */ | |
752 | |
753 topleft_xy = top_xy - 1; | |
754 topright_xy= top_xy + 1; | |
755 left_xy[1] = left_xy[0] = mb_xy-1; | |
756 left_block = left_block_options[0]; | |
757 if(FRAME_MBAFF){ | |
758 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; | |
759 const int top_pair_xy = pair_xy - s->mb_stride; | |
760 const int topleft_pair_xy = top_pair_xy - 1; | |
761 const int topright_pair_xy = top_pair_xy + 1; | |
762 const int topleft_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]); | |
763 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]); | |
764 const int topright_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]); | |
765 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); | |
766 const int curr_mb_field_flag = IS_INTERLACED(mb_type); | |
767 const int bottom = (s->mb_y & 1); | |
768 tprintf(s->avctx, "fill_caches: curr_mb_field_flag:%d, left_mb_field_flag:%d, topleft_mb_field_flag:%d, top_mb_field_flag:%d, topright_mb_field_flag:%d\n", curr_mb_field_flag, left_mb_field_flag, topleft_mb_field_flag, top_mb_field_flag, topright_mb_field_flag); | |
769 | |
770 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){ | |
771 top_xy -= s->mb_stride; | |
772 } | |
773 if (curr_mb_field_flag && (bottom || topleft_mb_field_flag)){ | |
774 topleft_xy -= s->mb_stride; | |
775 } else if(bottom && !curr_mb_field_flag && left_mb_field_flag) { | |
776 topleft_xy += s->mb_stride; | |
777 // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition | |
778 topleft_partition = 0; | |
779 } | |
780 if (curr_mb_field_flag && (bottom || topright_mb_field_flag)){ | |
781 topright_xy -= s->mb_stride; | |
782 } | |
783 if (left_mb_field_flag != curr_mb_field_flag) { | |
784 left_xy[1] = left_xy[0] = pair_xy - 1; | |
785 if (curr_mb_field_flag) { | |
786 left_xy[1] += s->mb_stride; | |
787 left_block = left_block_options[3]; | |
788 } else { | |
789 left_block= left_block_options[2 - bottom]; | |
790 } | |
791 } | |
792 } | |
793 | |
794 h->top_mb_xy = top_xy; | |
795 h->left_mb_xy[0] = left_xy[0]; | |
796 h->left_mb_xy[1] = left_xy[1]; | |
797 if(for_deblock){ | |
10910 | 798 |
799 //for sufficiently low qp, filtering wouldn't do anything | |
800 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
10928 | 801 int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice |
802 int qp = s->current_picture.qscale_table[mb_xy]; | |
803 if(qp <= qp_thresh | |
804 && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh) | |
805 && (left_xy[1]<0 || ((qp + s->current_picture.qscale_table[left_xy[1]] + 1)>>1) <= qp_thresh) | |
806 && (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){ | |
807 return 1; | |
808 } | |
10934
9b31065f013d
Dont waste time initializing stuff for deblocking intra mbs, none of
michael
parents:
10928
diff
changeset
|
809 if(IS_INTRA(mb_type)) |
9b31065f013d
Dont waste time initializing stuff for deblocking intra mbs, none of
michael
parents:
10928
diff
changeset
|
810 return 0; |
10910 | 811 |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
812 *((uint64_t*)&h->non_zero_count_cache[0+8*1])= *((uint64_t*)&h->non_zero_count[mb_xy][ 0]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
813 *((uint64_t*)&h->non_zero_count_cache[0+8*2])= *((uint64_t*)&h->non_zero_count[mb_xy][ 8]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
814 *((uint32_t*)&h->non_zero_count_cache[0+8*5])= *((uint32_t*)&h->non_zero_count[mb_xy][16]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
815 *((uint32_t*)&h->non_zero_count_cache[4+8*3])= *((uint32_t*)&h->non_zero_count[mb_xy][20]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
816 *((uint64_t*)&h->non_zero_count_cache[0+8*4])= *((uint64_t*)&h->non_zero_count[mb_xy][24]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
817 |
10917 | 818 h->cbp= h->cbp_table[mb_xy]; |
819 | |
10866 | 820 topleft_type = 0; |
821 topright_type = 0; | |
822 top_type = h->slice_table[top_xy ] < 0xFFFF ? s->current_picture.mb_type[top_xy] : 0; | |
823 left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0; | |
824 left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0; | |
825 | |
10906 | 826 if(!IS_INTRA(mb_type)){ |
10866 | 827 int list; |
828 for(list=0; list<h->list_count; list++){ | |
10906 | 829 int8_t *ref; |
830 int y, b_xy; | |
831 if(!USES_LIST(mb_type, list)){ | |
832 fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4); | |
10866 | 833 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = |
10906 | 834 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = |
10866 | 835 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = |
10906 | 836 *(uint32_t*)&h->ref_cache[list][scan8[10]] = ((LIST_NOT_USED)&0xFF)*0x01010101; |
837 continue; | |
10866 | 838 } |
10906 | 839 |
840 ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
841 if(for_deblock){ |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
842 int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
843 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
844 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
845 ref += h->b8_stride; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
846 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
847 *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
848 }else{ |
10906 | 849 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = |
850 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101; | |
851 ref += h->b8_stride; | |
852 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
853 *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
854 } |
10906 | 855 |
856 b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
857 for(y=0; y<4; y++){ | |
858 *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y]= *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]; | |
859 *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y]= *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]; | |
860 } | |
861 | |
10866 | 862 } |
863 } | |
864 }else{ | |
865 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
866 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
867 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
868 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
869 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
870 | |
10928 | 871 if(IS_INTRA(mb_type)){ |
872 int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1; | |
873 h->topleft_samples_available= | |
874 h->top_samples_available= | |
875 h->left_samples_available= 0xFFFF; | |
876 h->topright_samples_available= 0xEEEA; | |
10866 | 877 |
10928 | 878 if(!(top_type & type_mask)){ |
879 h->topleft_samples_available= 0xB3FF; | |
880 h->top_samples_available= 0x33FF; | |
881 h->topright_samples_available= 0x26EA; | |
882 } | |
883 if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){ | |
884 if(IS_INTERLACED(mb_type)){ | |
885 if(!(left_type[0] & type_mask)){ | |
886 h->topleft_samples_available&= 0xDFFF; | |
887 h->left_samples_available&= 0x5FFF; | |
888 } | |
889 if(!(left_type[1] & type_mask)){ | |
890 h->topleft_samples_available&= 0xFF5F; | |
891 h->left_samples_available&= 0xFF5F; | |
892 } | |
893 }else{ | |
894 int left_typei = h->slice_table[left_xy[0] + s->mb_stride ] == h->slice_num | |
895 ? s->current_picture.mb_type[left_xy[0] + s->mb_stride] : 0; | |
896 assert(left_xy[0] == left_xy[1]); | |
897 if(!((left_typei & type_mask) && (left_type[0] & type_mask))){ | |
898 h->topleft_samples_available&= 0xDF5F; | |
899 h->left_samples_available&= 0x5F5F; | |
900 } | |
10866 | 901 } |
902 }else{ | |
10928 | 903 if(!(left_type[0] & type_mask)){ |
10866 | 904 h->topleft_samples_available&= 0xDF5F; |
905 h->left_samples_available&= 0x5F5F; | |
906 } | |
907 } | |
908 | |
10928 | 909 if(!(topleft_type & type_mask)) |
910 h->topleft_samples_available&= 0x7FFF; | |
10866 | 911 |
10928 | 912 if(!(topright_type & type_mask)) |
913 h->topright_samples_available&= 0xFBFF; | |
10866 | 914 |
10928 | 915 if(IS_INTRA4x4(mb_type)){ |
916 if(IS_INTRA4x4(top_type)){ | |
917 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
918 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
919 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
920 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
10866 | 921 }else{ |
922 int pred; | |
10928 | 923 if(!(top_type & type_mask)) |
10866 | 924 pred= -1; |
925 else{ | |
926 pred= 2; | |
927 } | |
10928 | 928 h->intra4x4_pred_mode_cache[4+8*0]= |
929 h->intra4x4_pred_mode_cache[5+8*0]= | |
930 h->intra4x4_pred_mode_cache[6+8*0]= | |
931 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
932 } | |
933 for(i=0; i<2; i++){ | |
934 if(IS_INTRA4x4(left_type[i])){ | |
935 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
936 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
937 }else{ | |
938 int pred; | |
939 if(!(left_type[i] & type_mask)) | |
940 pred= -1; | |
941 else{ | |
942 pred= 2; | |
943 } | |
944 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
945 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
946 } | |
10866 | 947 } |
948 } | |
949 } | |
950 } | |
951 | |
952 | |
953 /* | |
954 0 . T T. T T T T | |
955 1 L . .L . . . . | |
956 2 L . .L . . . . | |
957 3 . T TL . . . . | |
958 4 L . .L . . . . | |
959 5 L . .. . . . . | |
960 */ | |
961 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec) | |
962 if(top_type){ | |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
963 *(uint32_t*)&h->non_zero_count_cache[4+8*0]= *(uint32_t*)&h->non_zero_count[top_xy][4+3*8]; |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
964 if(!for_deblock){ |
10928 | 965 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][1+1*8]; |
966 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][2+1*8]; | |
10866 | 967 |
10928 | 968 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][1+2*8]; |
969 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][2+2*8]; | |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
970 } |
10866 | 971 }else{ |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
972 if(for_deblock){ |
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
973 *(uint32_t*)&h->non_zero_count_cache[4+8*0]= 0; |
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
974 }else{ |
10866 | 975 |
10928 | 976 h->non_zero_count_cache[1+8*0]= |
977 h->non_zero_count_cache[2+8*0]= | |
10866 | 978 |
10928 | 979 h->non_zero_count_cache[1+8*3]= |
980 h->non_zero_count_cache[2+8*3]= | |
981 *(uint32_t*)&h->non_zero_count_cache[4+8*0]= CABAC && !IS_INTRA(mb_type) ? 0 : 0x40404040; | |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
982 } |
10866 | 983 |
984 } | |
985 | |
986 for (i=0; i<2; i++) { | |
987 if(left_type[i]){ | |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
988 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
|
989 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+1+2*i]]; |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
990 if(!for_deblock){ |
10928 | 991 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[8+4+2*i]]; |
992 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[8+5+2*i]]; | |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
993 } |
10866 | 994 }else{ |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
995 if(for_deblock){ |
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
996 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
997 h->non_zero_count_cache[3+8*2 + 2*8*i]= 0; |
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
998 }else{ |
10928 | 999 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
1000 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
1001 h->non_zero_count_cache[0+8*1 + 8*i]= | |
1002 h->non_zero_count_cache[0+8*4 + 8*i]= CABAC && !IS_INTRA(mb_type) ? 0 : 64; | |
10926
42cff5346e53
Dont init chroma elements of non_zero_count_cache for deblock.
michael
parents:
10925
diff
changeset
|
1003 } |
10866 | 1004 } |
1005 } | |
1006 | |
10914
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1007 // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1008 if(for_deblock && !CABAC && h->pps.transform_8x8_mode){ |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1009 if(IS_8x8DCT(top_type)){ |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1010 h->non_zero_count_cache[4+8*0]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1011 h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4; |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1012 h->non_zero_count_cache[6+8*0]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1013 h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8; |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1014 } |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1015 if(IS_8x8DCT(left_type[0])){ |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1016 h->non_zero_count_cache[3+8*1]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1017 h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1018 } |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1019 if(IS_8x8DCT(left_type[1])){ |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1020 h->non_zero_count_cache[3+8*3]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1021 h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1022 } |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1023 |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1024 if(IS_8x8DCT(mb_type)){ |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1025 h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1026 h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp_table[mb_xy] & 1; |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1027 |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1028 h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1029 h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp_table[mb_xy] & 2; |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1030 |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1031 h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1032 h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp_table[mb_xy] & 4; |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1033 |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1034 h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]= |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1035 h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp_table[mb_xy] & 8; |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1036 } |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1037 } |
edd918a4c0b8
Move CAVLC 8x8 DCT special case from ff_h264_filter_mb() to fill_caches
michael
parents:
10913
diff
changeset
|
1038 |
10908
28840dfd4b52
Disable a few things in fill_filter_caches() that arent needed.
michael
parents:
10907
diff
changeset
|
1039 if( CABAC && !for_deblock) { |
10866 | 1040 // top_cbp |
1041 if(top_type) { | |
1042 h->top_cbp = h->cbp_table[top_xy]; | |
1043 } else if(IS_INTRA(mb_type)) { | |
1044 h->top_cbp = 0x1C0; | |
1045 } else { | |
1046 h->top_cbp = 0; | |
1047 } | |
1048 // left_cbp | |
1049 if (left_type[0]) { | |
1050 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0; | |
1051 } else if(IS_INTRA(mb_type)) { | |
1052 h->left_cbp = 0x1C0; | |
1053 } else { | |
1054 h->left_cbp = 0; | |
1055 } | |
1056 if (left_type[0]) { | |
1057 h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1; | |
1058 } | |
1059 if (left_type[1]) { | |
1060 h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3; | |
1061 } | |
1062 } | |
1063 | |
1064 #if 1 | |
1065 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ | |
1066 int list; | |
1067 for(list=0; list<h->list_count; list++){ | |
1068 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ | |
1069 /*if(!h->mv_cache_clean[list]){ | |
1070 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
1071 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
1072 h->mv_cache_clean[list]= 1; | |
1073 }*/ | |
1074 continue; | |
1075 } | |
1076 h->mv_cache_clean[list]= 0; | |
1077 | |
1078 if(USES_LIST(top_type, list)){ | |
1079 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; | |
1080 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
1081 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
1082 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
1083 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
1084 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1085 if(for_deblock){ |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1086 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1087 h->ref_cache[list][scan8[0] + 0 - 1*8]= |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1088 h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]]; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1089 h->ref_cache[list][scan8[0] + 2 - 1*8]= |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1090 h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]]; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1091 }else{ |
10928 | 1092 h->ref_cache[list][scan8[0] + 0 - 1*8]= |
1093 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
1094 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
1095 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1096 } |
10866 | 1097 }else{ |
1098 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= | |
1099 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
1100 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1101 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1102 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= (((for_deblock||top_type) ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; |
10866 | 1103 } |
1104 | |
1105 for(i=0; i<2; i++){ | |
1106 int cache_idx = scan8[0] - 1 + i*2*8; | |
1107 if(USES_LIST(left_type[i], list)){ | |
1108 const int b_xy= h->mb2b_xy[left_xy[i]] + 3; | |
1109 const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1; | |
1110 *(uint32_t*)h->mv_cache[list][cache_idx ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]]; | |
1111 *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]]; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1112 if(for_deblock){ |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1113 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[i]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1114 h->ref_cache[list][cache_idx ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)]]; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1115 h->ref_cache[list][cache_idx+8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)]]; |
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1116 }else{ |
10928 | 1117 h->ref_cache[list][cache_idx ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)]; |
1118 h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)]; | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1119 } |
10866 | 1120 }else{ |
1121 *(uint32_t*)h->mv_cache [list][cache_idx ]= | |
1122 *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0; | |
1123 h->ref_cache[list][cache_idx ]= | |
10913
497929e9d912
Perform reference remapping at fill_cache() time instead of in the
michael
parents:
10912
diff
changeset
|
1124 h->ref_cache[list][cache_idx+8]= (for_deblock||left_type[i]) ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
10866 | 1125 } |
1126 } | |
1127 | |
1128 if(for_deblock || ((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF)) | |
1129 continue; | |
1130 | |
1131 if(USES_LIST(topleft_type, list)){ | |
1132 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + h->b_stride + (topleft_partition & 2*h->b_stride); | |
1133 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (topleft_partition & h->b8_stride); | |
1134 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; | |
1135 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy]; | |
1136 }else{ | |
1137 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0; | |
1138 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
1139 } | |
1140 | |
1141 if(USES_LIST(topright_type, list)){ | |
1142 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride; | |
1143 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride; | |
1144 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; | |
1145 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy]; | |
1146 }else{ | |
1147 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0; | |
1148 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
1149 } | |
1150 | |
1151 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) | |
1152 continue; | |
1153 | |
1154 h->ref_cache[list][scan8[5 ]+1] = | |
1155 h->ref_cache[list][scan8[7 ]+1] = | |
1156 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) | |
1157 h->ref_cache[list][scan8[4 ]] = | |
1158 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; | |
1159 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
1160 *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]= | |
1161 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) | |
1162 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= | |
1163 *(uint32_t*)h->mv_cache [list][scan8[12]]= 0; | |
1164 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
1165 if( CABAC ) { |
10866 | 1166 /* XXX beurk, Load mvd */ |
1167 if(USES_LIST(top_type, list)){ | |
1168 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; | |
1169 *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0]; | |
1170 *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1]; | |
1171 *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2]; | |
1172 *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3]; | |
1173 }else{ | |
1174 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= | |
1175 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
1176 *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]= | |
1177 *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0; | |
1178 } | |
1179 if(USES_LIST(left_type[0], list)){ | |
1180 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; | |
1181 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]]; | |
1182 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]]; | |
1183 }else{ | |
1184 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]= | |
1185 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0; | |
1186 } | |
1187 if(USES_LIST(left_type[1], list)){ | |
1188 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; | |
1189 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]]; | |
1190 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]]; | |
1191 }else{ | |
1192 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]= | |
1193 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0; | |
1194 } | |
1195 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]= | |
1196 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]= | |
1197 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) | |
1198 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]= | |
1199 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; | |
1200 | |
1201 if(h->slice_type_nos == FF_B_TYPE){ | |
1202 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
1203 | |
1204 if(IS_DIRECT(top_type)){ | |
1205 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
1206 }else if(IS_8X8(top_type)){ | |
1207 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
1208 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
1209 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
1210 }else{ | |
1211 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
1212 } | |
1213 | |
1214 if(IS_DIRECT(left_type[0])) | |
1215 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
1216 else if(IS_8X8(left_type[0])) | |
1217 h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)]; | |
1218 else | |
1219 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
1220 | |
1221 if(IS_DIRECT(left_type[1])) | |
1222 h->direct_cache[scan8[0] - 1 + 2*8]= 1; | |
1223 else if(IS_8X8(left_type[1])) | |
1224 h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)]; | |
1225 else | |
1226 h->direct_cache[scan8[0] - 1 + 2*8]= 0; | |
1227 } | |
1228 } | |
1229 | |
1230 if(FRAME_MBAFF){ | |
1231 #define MAP_MVS\ | |
1232 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
1233 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
1234 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
1235 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
1236 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
1237 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
1238 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
1239 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
1240 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
1241 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
1242 if(MB_FIELD){ | |
1243 #define MAP_F2F(idx, mb_type)\ | |
1244 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
1245 h->ref_cache[list][idx] <<= 1;\ | |
1246 h->mv_cache[list][idx][1] /= 2;\ | |
1247 h->mvd_cache[list][idx][1] /= 2;\ | |
1248 } | |
1249 MAP_MVS | |
1250 #undef MAP_F2F | |
1251 }else{ | |
1252 #define MAP_F2F(idx, mb_type)\ | |
1253 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
1254 h->ref_cache[list][idx] >>= 1;\ | |
1255 h->mv_cache[list][idx][1] <<= 1;\ | |
1256 h->mvd_cache[list][idx][1] <<= 1;\ | |
1257 } | |
1258 MAP_MVS | |
1259 #undef MAP_F2F | |
1260 } | |
1261 } | |
1262 } | |
1263 } | |
1264 #endif | |
1265 | |
10908
28840dfd4b52
Disable a few things in fill_filter_caches() that arent needed.
michael
parents:
10907
diff
changeset
|
1266 if(!for_deblock) |
10928 | 1267 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); |
10910 | 1268 return 0; |
10866 | 1269 } |
1270 | |
10907 | 1271 static void fill_decode_caches(H264Context *h, int mb_type){ |
1272 fill_caches(h, mb_type, 0); | |
1273 } | |
1274 | |
10910 | 1275 /** |
1276 * | |
1277 * @returns non zero if the loop filter can be skiped | |
1278 */ | |
1279 static int fill_filter_caches(H264Context *h, int mb_type){ | |
1280 return fill_caches(h, mb_type, 1); | |
10907 | 1281 } |
1282 | |
10866 | 1283 /** |
1284 * gets the predicted intra4x4 prediction mode. | |
1285 */ | |
1286 static inline int pred_intra_mode(H264Context *h, int n){ | |
1287 const int index8= scan8[n]; | |
1288 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1289 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1290 const int min= FFMIN(left, top); | |
1291 | |
1292 tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min); | |
1293 | |
1294 if(min<0) return DC_PRED; | |
1295 else return min; | |
1296 } | |
1297 | |
1298 static inline void write_back_non_zero_count(H264Context *h){ | |
1299 const int mb_xy= h->mb_xy; | |
1300 | |
10909
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
1301 *((uint64_t*)&h->non_zero_count[mb_xy][ 0]) = *((uint64_t*)&h->non_zero_count_cache[0+8*1]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
1302 *((uint64_t*)&h->non_zero_count[mb_xy][ 8]) = *((uint64_t*)&h->non_zero_count_cache[0+8*2]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
1303 *((uint32_t*)&h->non_zero_count[mb_xy][16]) = *((uint32_t*)&h->non_zero_count_cache[0+8*5]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
1304 *((uint32_t*)&h->non_zero_count[mb_xy][20]) = *((uint32_t*)&h->non_zero_count_cache[4+8*3]); |
f4cf3960b8c6
Reorganize how values are stored in h->non_zero_count.
michael
parents:
10908
diff
changeset
|
1305 *((uint64_t*)&h->non_zero_count[mb_xy][24]) = *((uint64_t*)&h->non_zero_count_cache[0+8*4]); |
10866 | 1306 } |
1307 | |
1308 static inline void write_back_motion(H264Context *h, int mb_type){ | |
1309 MpegEncContext * const s = &h->s; | |
1310 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1311 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1312 int list; | |
1313 | |
1314 if(!USES_LIST(mb_type, 0)) | |
1315 fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1); | |
1316 | |
1317 for(list=0; list<h->list_count; list++){ | |
1318 int y; | |
1319 if(!USES_LIST(mb_type, list)) | |
1320 continue; | |
1321 | |
1322 for(y=0; y<4; y++){ | |
1323 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y]; | |
1324 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y]; | |
1325 } | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
1326 if( CABAC ) { |
10866 | 1327 if(IS_SKIP(mb_type)) |
1328 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1329 else | |
1330 for(y=0; y<4; y++){ | |
1331 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y]; | |
1332 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y]; | |
1333 } | |
1334 } | |
1335 | |
1336 { | |
1337 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; | |
1338 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; | |
1339 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1340 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1341 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1342 } | |
1343 } | |
1344 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10883
diff
changeset
|
1345 if(h->slice_type_nos == FF_B_TYPE && CABAC){ |
10866 | 1346 if(IS_8X8(mb_type)){ |
1347 uint8_t *direct_table = &h->direct_table[b8_xy]; | |
1348 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1349 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1350 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
1351 } | |
1352 } | |
1353 } | |
1354 | |
1355 static inline int get_dct8x8_allowed(H264Context *h){ | |
1356 if(h->sps.direct_8x8_inference_flag) | |
1357 return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8 )*0x0001000100010001ULL)); | |
1358 else | |
1359 return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8|MB_TYPE_DIRECT2)*0x0001000100010001ULL)); | |
1360 } | |
1361 | |
1362 static void predict_field_decoding_flag(H264Context *h){ | |
1363 MpegEncContext * const s = &h->s; | |
1364 const int mb_xy= h->mb_xy; | |
1365 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
1366 ? s->current_picture.mb_type[mb_xy-1] | |
1367 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
1368 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
1369 : 0; | |
1370 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
1371 } | |
1372 | |
1373 /** | |
1374 * decodes a P_SKIP or B_SKIP macroblock | |
1375 */ | |
1376 static void decode_mb_skip(H264Context *h){ | |
1377 MpegEncContext * const s = &h->s; | |
1378 const int mb_xy= h->mb_xy; | |
1379 int mb_type=0; | |
1380 | |
10906 | 1381 memset(h->non_zero_count[mb_xy], 0, 32); |
10866 | 1382 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui |
1383 | |
1384 if(MB_FIELD) | |
1385 mb_type|= MB_TYPE_INTERLACED; | |
1386 | |
1387 if( h->slice_type_nos == FF_B_TYPE ) | |
1388 { | |
1389 // just for fill_caches. pred_direct_motion will set the real mb_type | |
1390 mb_type|= MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; | |
1391 | |
10907 | 1392 fill_decode_caches(h, mb_type); //FIXME check what is needed and what not ... |
10866 | 1393 ff_h264_pred_direct_motion(h, &mb_type); |
1394 mb_type|= MB_TYPE_SKIP; | |
1395 } | |
1396 else | |
1397 { | |
1398 int mx, my; | |
1399 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; | |
1400 | |
10907 | 1401 fill_decode_caches(h, mb_type); //FIXME check what is needed and what not ... |
10866 | 1402 pred_pskip_motion(h, &mx, &my); |
1403 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1404 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
1405 } | |
1406 | |
1407 write_back_motion(h, mb_type); | |
1408 s->current_picture.mb_type[mb_xy]= mb_type; | |
1409 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1410 h->slice_table[ mb_xy ]= h->slice_num; | |
1411 h->prev_mb_skipped= 1; | |
1412 } | |
1413 | |
10883
4701b9355d93
Add forgotten include of h264_mvpred.h to h264.h.
michael
parents:
10869
diff
changeset
|
1414 #include "h264_mvpred.h" //For pred_pskip_motion() |
4701b9355d93
Add forgotten include of h264_mvpred.h to h264.h.
michael
parents:
10869
diff
changeset
|
1415 |
7760 | 1416 #endif /* AVCODEC_H264_H */ |