Mercurial > libavcodec.hg
annotate h264.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | 2844b8cf4e11 |
children | 4d6d056a00c6 |
rev | line source |
---|---|
1168 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
5 * This library is free software; you can redistribute it and/or | |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2 of the License, or (at your option) any later version. | |
9 * | |
10 * This library is distributed in the hope that it will be useful, | |
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 * Lesser General Public License for more details. | |
14 * | |
15 * You should have received a copy of the GNU Lesser General Public | |
16 * License along with this library; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 * | |
19 */ | |
20 | |
21 /** | |
22 * @file h264.c | |
23 * H.264 / AVC / MPEG4 part10 codec. | |
24 * @author Michael Niedermayer <michaelni@gmx.at> | |
25 */ | |
26 | |
27 #include "common.h" | |
28 #include "dsputil.h" | |
29 #include "avcodec.h" | |
30 #include "mpegvideo.h" | |
31 #include "h264data.h" | |
32 #include "golomb.h" | |
33 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
34 #include "cabac.h" |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
35 |
1168 | 36 #undef NDEBUG |
37 #include <assert.h> | |
38 | |
39 #define interlaced_dct interlaced_dct_is_a_bad_name | |
40 #define mb_intra mb_intra_isnt_initalized_see_mb_type | |
41 | |
42 #define LUMA_DC_BLOCK_INDEX 25 | |
43 #define CHROMA_DC_BLOCK_INDEX 26 | |
44 | |
45 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
46 #define COEFF_TOKEN_VLC_BITS 8 | |
47 #define TOTAL_ZEROS_VLC_BITS 9 | |
48 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
49 #define RUN_VLC_BITS 3 | |
50 #define RUN7_VLC_BITS 6 | |
51 | |
52 #define MAX_SPS_COUNT 32 | |
53 #define MAX_PPS_COUNT 256 | |
54 | |
55 #define MAX_MMCO_COUNT 66 | |
56 | |
57 /** | |
58 * Sequence parameter set | |
59 */ | |
60 typedef struct SPS{ | |
61 | |
62 int profile_idc; | |
63 int level_idc; | |
64 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 | |
65 int poc_type; ///< pic_order_cnt_type | |
66 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
67 int delta_pic_order_always_zero_flag; | |
68 int offset_for_non_ref_pic; | |
69 int offset_for_top_to_bottom_field; | |
70 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
71 int ref_frame_count; ///< num_ref_frames | |
1371 | 72 int gaps_in_frame_num_allowed_flag; |
1168 | 73 int mb_width; ///< frame_width_in_mbs_minus1 + 1 |
74 int mb_height; ///< frame_height_in_mbs_minus1 + 1 | |
75 int frame_mbs_only_flag; | |
76 int mb_aff; ///<mb_adaptive_frame_field_flag | |
77 int direct_8x8_inference_flag; | |
1371 | 78 int crop; ///< frame_cropping_flag |
79 int crop_left; ///< frame_cropping_rect_left_offset | |
80 int crop_right; ///< frame_cropping_rect_right_offset | |
81 int crop_top; ///< frame_cropping_rect_top_offset | |
82 int crop_bottom; ///< frame_cropping_rect_bottom_offset | |
1168 | 83 int vui_parameters_present_flag; |
1548 | 84 AVRational sar; |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
85 int timing_info_present_flag; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
86 uint32_t num_units_in_tick; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
87 uint32_t time_scale; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
88 int fixed_frame_rate_flag; |
1168 | 89 short offset_for_ref_frame[256]; //FIXME dyn aloc? |
90 }SPS; | |
91 | |
92 /** | |
93 * Picture parameter set | |
94 */ | |
95 typedef struct PPS{ | |
96 int sps_id; | |
97 int cabac; ///< entropy_coding_mode_flag | |
98 int pic_order_present; ///< pic_order_present_flag | |
99 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
100 int mb_slice_group_map_type; | |
101 int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 | |
102 int weighted_pred; ///< weighted_pred_flag | |
103 int weighted_bipred_idc; | |
104 int init_qp; ///< pic_init_qp_minus26 + 26 | |
105 int init_qs; ///< pic_init_qs_minus26 + 26 | |
106 int chroma_qp_index_offset; | |
107 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag | |
108 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
109 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
110 }PPS; | |
111 | |
112 /** | |
113 * Memory management control operation opcode. | |
114 */ | |
115 typedef enum MMCOOpcode{ | |
116 MMCO_END=0, | |
117 MMCO_SHORT2UNUSED, | |
118 MMCO_LONG2UNUSED, | |
119 MMCO_SHORT2LONG, | |
120 MMCO_SET_MAX_LONG, | |
121 MMCO_RESET, | |
122 MMCO_LONG, | |
123 } MMCOOpcode; | |
124 | |
125 /** | |
126 * Memory management control operation. | |
127 */ | |
128 typedef struct MMCO{ | |
129 MMCOOpcode opcode; | |
130 int short_frame_num; | |
131 int long_index; | |
132 } MMCO; | |
133 | |
134 /** | |
135 * H264Context | |
136 */ | |
137 typedef struct H264Context{ | |
138 MpegEncContext s; | |
139 int nal_ref_idc; | |
140 int nal_unit_type; | |
141 #define NAL_SLICE 1 | |
142 #define NAL_DPA 2 | |
143 #define NAL_DPB 3 | |
144 #define NAL_DPC 4 | |
145 #define NAL_IDR_SLICE 5 | |
146 #define NAL_SEI 6 | |
147 #define NAL_SPS 7 | |
148 #define NAL_PPS 8 | |
149 #define NAL_PICTURE_DELIMITER 9 | |
150 #define NAL_FILTER_DATA 10 | |
151 uint8_t *rbsp_buffer; | |
152 int rbsp_buffer_size; | |
153 | |
2227 | 154 /** |
155 * Used to parse AVC variant of h264 | |
156 */ | |
157 int is_avc; ///< this flag is != 0 if codec is avc1 | |
158 int got_avcC; ///< flag used to parse avcC data only once | |
159 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
160 | |
1168 | 161 int chroma_qp; //QPc |
162 | |
163 int prev_mb_skiped; //FIXME remove (IMHO not used) | |
164 | |
165 //prediction stuff | |
166 int chroma_pred_mode; | |
167 int intra16x16_pred_mode; | |
168 | |
169 int8_t intra4x4_pred_mode_cache[5*8]; | |
170 int8_t (*intra4x4_pred_mode)[8]; | |
171 void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp? | |
172 void (*pred8x8 [4+3])(uint8_t *src, int stride); | |
173 void (*pred16x16[4+3])(uint8_t *src, int stride); | |
174 unsigned int topleft_samples_available; | |
175 unsigned int top_samples_available; | |
176 unsigned int topright_samples_available; | |
177 unsigned int left_samples_available; | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
178 uint8_t (*top_border)[16+2*8]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
179 uint8_t left_border[17+2*9]; |
1168 | 180 |
181 /** | |
182 * non zero coeff count cache. | |
183 * is 64 if not available. | |
184 */ | |
2471
805431763e84
fixing missaligned memory accesses in fill_rectangle()
michael
parents:
2454
diff
changeset
|
185 uint8_t non_zero_count_cache[6*8] __align8; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
186 uint8_t (*non_zero_count)[16]; |
1168 | 187 |
188 /** | |
189 * Motion vector cache. | |
190 */ | |
2471
805431763e84
fixing missaligned memory accesses in fill_rectangle()
michael
parents:
2454
diff
changeset
|
191 int16_t mv_cache[2][5*8][2] __align8; |
805431763e84
fixing missaligned memory accesses in fill_rectangle()
michael
parents:
2454
diff
changeset
|
192 int8_t ref_cache[2][5*8] __align8; |
1168 | 193 #define LIST_NOT_USED -1 //FIXME rename? |
194 #define PART_NOT_AVAILABLE -2 | |
195 | |
196 /** | |
197 * is 1 if the specific list MV&references are set to 0,0,-2. | |
198 */ | |
199 int mv_cache_clean[2]; | |
200 | |
201 int block_offset[16+8]; | |
202 int chroma_subblock_offset[16]; //FIXME remove | |
203 | |
204 uint16_t *mb2b_xy; //FIXME are these 4 a good idea? | |
205 uint16_t *mb2b8_xy; | |
2395 | 206 int b_stride; //FIXME use s->b4_stride |
1168 | 207 int b8_stride; |
208 | |
1234 | 209 int halfpel_flag; |
210 int thirdpel_flag; | |
211 | |
1319 | 212 int unknown_svq3_flag; |
213 int next_slice_index; | |
214 | |
1168 | 215 SPS sps_buffer[MAX_SPS_COUNT]; |
216 SPS sps; ///< current sps | |
217 | |
218 PPS pps_buffer[MAX_PPS_COUNT]; | |
219 /** | |
220 * current pps | |
221 */ | |
222 PPS pps; //FIXME move tp Picture perhaps? (->no) do we need that? | |
223 | |
224 int slice_num; | |
225 uint8_t *slice_table_base; | |
226 uint8_t *slice_table; ///< slice_table_base + mb_stride + 1 | |
227 int slice_type; | |
228 int slice_type_fixed; | |
229 | |
230 //interlacing specific flags | |
231 int mb_field_decoding_flag; | |
232 | |
233 int sub_mb_type[4]; | |
234 | |
235 //POC stuff | |
236 int poc_lsb; | |
237 int poc_msb; | |
238 int delta_poc_bottom; | |
239 int delta_poc[2]; | |
240 int frame_num; | |
241 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
242 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
243 int frame_num_offset; ///< for POC type 2 | |
244 int prev_frame_num_offset; ///< for POC type 2 | |
245 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
246 | |
247 /** | |
248 * frame_num for frames or 2*frame_num for field pics. | |
249 */ | |
250 int curr_pic_num; | |
251 | |
252 /** | |
253 * max_frame_num or 2*max_frame_num for field pics. | |
254 */ | |
255 int max_pic_num; | |
256 | |
257 //Weighted pred stuff | |
2415 | 258 int use_weight; |
259 int use_weight_chroma; | |
1168 | 260 int luma_log2_weight_denom; |
261 int chroma_log2_weight_denom; | |
262 int luma_weight[2][16]; | |
263 int luma_offset[2][16]; | |
264 int chroma_weight[2][16][2]; | |
265 int chroma_offset[2][16][2]; | |
2415 | 266 int implicit_weight[16][16]; |
1168 | 267 |
268 //deblock | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
269 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
270 int slice_alpha_c0_offset; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
271 int slice_beta_offset; |
1168 | 272 |
273 int redundant_pic_count; | |
274 | |
275 int direct_spatial_mv_pred; | |
2396 | 276 int dist_scale_factor[16]; |
1168 | 277 |
278 /** | |
279 * num_ref_idx_l0/1_active_minus1 + 1 | |
280 */ | |
281 int ref_count[2];// FIXME split for AFF | |
282 Picture *short_ref[16]; | |
283 Picture *long_ref[16]; | |
284 Picture default_ref_list[2][32]; | |
285 Picture ref_list[2][32]; //FIXME size? | |
286 Picture field_ref_list[2][32]; //FIXME size? | |
2409 | 287 Picture *delayed_pic[16]; //FIXME size? |
1168 | 288 |
289 /** | |
290 * memory management control operations buffer. | |
291 */ | |
292 MMCO mmco[MAX_MMCO_COUNT]; | |
293 int mmco_index; | |
294 | |
295 int long_ref_count; ///< number of actual long term references | |
296 int short_ref_count; ///< number of actual short term references | |
297 | |
298 //data partitioning | |
299 GetBitContext intra_gb; | |
300 GetBitContext inter_gb; | |
301 GetBitContext *intra_gb_ptr; | |
302 GetBitContext *inter_gb_ptr; | |
303 | |
304 DCTELEM mb[16*24] __align8; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
305 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
306 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
307 * Cabac |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
308 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
309 CABACContext cabac; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
310 uint8_t cabac_state[399]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
311 int cabac_init_idc; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
312 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
313 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
314 uint16_t *cbp_table; |
2314 | 315 int top_cbp; |
316 int left_cbp; | |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
317 /* chroma_pred_mode for i4x4 or i16x16, else 0 */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
318 uint8_t *chroma_pred_mode_table; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
319 int last_qscale_diff; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
320 int16_t (*mvd_table[2])[2]; |
2471
805431763e84
fixing missaligned memory accesses in fill_rectangle()
michael
parents:
2454
diff
changeset
|
321 int16_t mvd_cache[2][5*8][2] __align8; |
2396 | 322 uint8_t *direct_table; |
323 uint8_t direct_cache[5*8]; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
324 |
1168 | 325 }H264Context; |
326 | |
327 static VLC coeff_token_vlc[4]; | |
328 static VLC chroma_dc_coeff_token_vlc; | |
329 | |
330 static VLC total_zeros_vlc[15]; | |
331 static VLC chroma_dc_total_zeros_vlc[3]; | |
332 | |
333 static VLC run_vlc[6]; | |
334 static VLC run7_vlc; | |
335 | |
1234 | 336 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
337 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc); | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
338 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr); |
1234 | 339 |
1269 | 340 static inline uint32_t pack16to32(int a, int b){ |
341 #ifdef WORDS_BIGENDIAN | |
342 return (b&0xFFFF) + (a<<16); | |
343 #else | |
344 return (a&0xFFFF) + (b<<16); | |
345 #endif | |
346 } | |
347 | |
1168 | 348 /** |
349 * fill a rectangle. | |
2392 | 350 * @param h height of the rectangle, should be a constant |
351 * @param w width of the rectangle, should be a constant | |
1168 | 352 * @param size the size of val (1 or 4), should be a constant |
353 */ | |
1187 | 354 static inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ //FIXME ensure this IS inlined |
355 uint8_t *p= (uint8_t*)vp; | |
1168 | 356 assert(size==1 || size==4); |
357 | |
358 w *= size; | |
359 stride *= size; | |
360 | |
2471
805431763e84
fixing missaligned memory accesses in fill_rectangle()
michael
parents:
2454
diff
changeset
|
361 assert((((int)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
1168 | 362 //FIXME check what gcc generates for 64 bit on x86 and possible write a 32 bit ver of it |
363 if(w==2 && h==2){ | |
364 *(uint16_t*)(p + 0)= | |
365 *(uint16_t*)(p + stride)= size==4 ? val : val*0x0101; | |
366 }else if(w==2 && h==4){ | |
367 *(uint16_t*)(p + 0*stride)= | |
368 *(uint16_t*)(p + 1*stride)= | |
369 *(uint16_t*)(p + 2*stride)= | |
370 *(uint16_t*)(p + 3*stride)= size==4 ? val : val*0x0101; | |
1252 | 371 }else if(w==4 && h==1){ |
372 *(uint32_t*)(p + 0*stride)= size==4 ? val : val*0x01010101; | |
1168 | 373 }else if(w==4 && h==2){ |
374 *(uint32_t*)(p + 0*stride)= | |
375 *(uint32_t*)(p + 1*stride)= size==4 ? val : val*0x01010101; | |
376 }else if(w==4 && h==4){ | |
377 *(uint32_t*)(p + 0*stride)= | |
378 *(uint32_t*)(p + 1*stride)= | |
379 *(uint32_t*)(p + 2*stride)= | |
380 *(uint32_t*)(p + 3*stride)= size==4 ? val : val*0x01010101; | |
381 }else if(w==8 && h==1){ | |
382 *(uint32_t*)(p + 0)= | |
383 *(uint32_t*)(p + 4)= size==4 ? val : val*0x01010101; | |
384 }else if(w==8 && h==2){ | |
385 *(uint32_t*)(p + 0 + 0*stride)= | |
386 *(uint32_t*)(p + 4 + 0*stride)= | |
387 *(uint32_t*)(p + 0 + 1*stride)= | |
388 *(uint32_t*)(p + 4 + 1*stride)= size==4 ? val : val*0x01010101; | |
389 }else if(w==8 && h==4){ | |
390 *(uint64_t*)(p + 0*stride)= | |
391 *(uint64_t*)(p + 1*stride)= | |
392 *(uint64_t*)(p + 2*stride)= | |
393 *(uint64_t*)(p + 3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL; | |
394 }else if(w==16 && h==2){ | |
395 *(uint64_t*)(p + 0+0*stride)= | |
396 *(uint64_t*)(p + 8+0*stride)= | |
397 *(uint64_t*)(p + 0+1*stride)= | |
398 *(uint64_t*)(p + 8+1*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL; | |
399 }else if(w==16 && h==4){ | |
400 *(uint64_t*)(p + 0+0*stride)= | |
401 *(uint64_t*)(p + 8+0*stride)= | |
402 *(uint64_t*)(p + 0+1*stride)= | |
403 *(uint64_t*)(p + 8+1*stride)= | |
404 *(uint64_t*)(p + 0+2*stride)= | |
405 *(uint64_t*)(p + 8+2*stride)= | |
406 *(uint64_t*)(p + 0+3*stride)= | |
407 *(uint64_t*)(p + 8+3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL; | |
408 }else | |
409 assert(0); | |
410 } | |
411 | |
2449 | 412 static inline void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 413 MpegEncContext * const s = &h->s; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
414 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 415 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
416 int topleft_type, top_type, topright_type, left_type[2]; | |
417 int left_block[4]; | |
418 int i; | |
419 | |
420 //wow what a mess, why didnt they simplify the interlacing&intra stuff, i cant imagine that these complex rules are worth it | |
421 | |
422 if(h->sps.mb_aff){ | |
423 //FIXME | |
1453 | 424 topleft_xy = 0; /* avoid warning */ |
425 top_xy = 0; /* avoid warning */ | |
426 topright_xy = 0; /* avoid warning */ | |
1168 | 427 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
428 topleft_xy = mb_xy-1 - s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
429 top_xy = mb_xy - s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
430 topright_xy= mb_xy+1 - s->mb_stride; |
1168 | 431 left_xy[0] = mb_xy-1; |
432 left_xy[1] = mb_xy-1; | |
433 left_block[0]= 0; | |
434 left_block[1]= 1; | |
435 left_block[2]= 2; | |
436 left_block[3]= 3; | |
437 } | |
438 | |
2449 | 439 if(for_deblock){ |
440 topleft_type = h->slice_table[topleft_xy ] < 255 ? s->current_picture.mb_type[topleft_xy] : 0; | |
441 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; | |
442 topright_type= h->slice_table[topright_xy] < 255 ? s->current_picture.mb_type[topright_xy]: 0; | |
443 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
444 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
445 }else{ | |
446 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
447 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
448 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
449 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
450 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
451 } | |
1168 | 452 |
453 if(IS_INTRA(mb_type)){ | |
454 h->topleft_samples_available= | |
455 h->top_samples_available= | |
456 h->left_samples_available= 0xFFFF; | |
457 h->topright_samples_available= 0xEEEA; | |
458 | |
459 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
460 h->topleft_samples_available= 0xB3FF; | |
461 h->top_samples_available= 0x33FF; | |
462 h->topright_samples_available= 0x26EA; | |
463 } | |
464 for(i=0; i<2; i++){ | |
465 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
466 h->topleft_samples_available&= 0xDF5F; | |
467 h->left_samples_available&= 0x5F5F; | |
468 } | |
469 } | |
470 | |
471 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) | |
472 h->topleft_samples_available&= 0x7FFF; | |
473 | |
474 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) | |
475 h->topright_samples_available&= 0xFBFF; | |
476 | |
477 if(IS_INTRA4x4(mb_type)){ | |
478 if(IS_INTRA4x4(top_type)){ | |
479 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
480 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
481 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
482 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
483 }else{ | |
484 int pred; | |
485 if(IS_INTRA16x16(top_type) || (IS_INTER(top_type) && !h->pps.constrained_intra_pred)) | |
486 pred= 2; | |
487 else{ | |
488 pred= -1; | |
489 } | |
490 h->intra4x4_pred_mode_cache[4+8*0]= | |
491 h->intra4x4_pred_mode_cache[5+8*0]= | |
492 h->intra4x4_pred_mode_cache[6+8*0]= | |
493 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
494 } | |
495 for(i=0; i<2; i++){ | |
496 if(IS_INTRA4x4(left_type[i])){ | |
497 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
498 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
499 }else{ | |
500 int pred; | |
501 if(IS_INTRA16x16(left_type[i]) || (IS_INTER(left_type[i]) && !h->pps.constrained_intra_pred)) | |
502 pred= 2; | |
503 else{ | |
504 pred= -1; | |
505 } | |
506 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
507 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
508 } | |
509 } | |
510 } | |
511 } | |
512 | |
513 | |
514 /* | |
515 0 . T T. T T T T | |
516 1 L . .L . . . . | |
517 2 L . .L . . . . | |
518 3 . T TL . . . . | |
519 4 L . .L . . . . | |
520 5 L . .. . . . . | |
521 */ | |
522 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
523 if(top_type){ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
524 h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][0]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
525 h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][1]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
526 h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][2]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
527 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
1168 | 528 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
529 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][7]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
530 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
1168 | 531 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
532 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][10]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
533 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2314 | 534 |
535 h->top_cbp= h->cbp_table[top_xy]; | |
1168 | 536 }else{ |
537 h->non_zero_count_cache[4+8*0]= | |
538 h->non_zero_count_cache[5+8*0]= | |
539 h->non_zero_count_cache[6+8*0]= | |
540 h->non_zero_count_cache[7+8*0]= | |
541 | |
542 h->non_zero_count_cache[1+8*0]= | |
543 h->non_zero_count_cache[2+8*0]= | |
544 | |
545 h->non_zero_count_cache[1+8*3]= | |
2314 | 546 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
547 | |
548 if(IS_INTRA(mb_type)) h->top_cbp= 0x1C0; | |
549 else h->top_cbp= 0; | |
1168 | 550 } |
551 | |
552 if(left_type[0]){ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
553 h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][6]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
554 h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][5]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
555 h->non_zero_count_cache[0+8*1]= h->non_zero_count[left_xy[0]][9]; //FIXME left_block |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
556 h->non_zero_count_cache[0+8*4]= h->non_zero_count[left_xy[0]][12]; |
2314 | 557 h->left_cbp= h->cbp_table[left_xy[0]]; //FIXME interlacing |
1168 | 558 }else{ |
559 h->non_zero_count_cache[3+8*1]= | |
560 h->non_zero_count_cache[3+8*2]= | |
561 h->non_zero_count_cache[0+8*1]= | |
2314 | 562 h->non_zero_count_cache[0+8*4]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
563 | |
564 if(IS_INTRA(mb_type)) h->left_cbp= 0x1C0;//FIXME interlacing | |
565 else h->left_cbp= 0; | |
1168 | 566 } |
567 | |
568 if(left_type[1]){ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
569 h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[1]][4]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
570 h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[1]][3]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
571 h->non_zero_count_cache[0+8*2]= h->non_zero_count[left_xy[1]][8]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
572 h->non_zero_count_cache[0+8*5]= h->non_zero_count[left_xy[1]][11]; |
1168 | 573 }else{ |
574 h->non_zero_count_cache[3+8*3]= | |
575 h->non_zero_count_cache[3+8*4]= | |
576 h->non_zero_count_cache[0+8*2]= | |
2314 | 577 h->non_zero_count_cache[0+8*5]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
1168 | 578 } |
579 | |
580 #if 1 | |
2396 | 581 //FIXME direct mb can skip much of this |
582 if(IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)){ | |
1168 | 583 int list; |
584 for(list=0; list<2; list++){ | |
2396 | 585 if((!IS_8X8(mb_type)) && !USES_LIST(mb_type, list) && !IS_DIRECT(mb_type)){ |
1168 | 586 /*if(!h->mv_cache_clean[list]){ |
587 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
588 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
589 h->mv_cache_clean[list]= 1; | |
590 }*/ | |
2396 | 591 continue; |
1168 | 592 } |
593 h->mv_cache_clean[list]= 0; | |
594 | |
595 if(IS_INTER(topleft_type)){ | |
596 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride; | |
597 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride; | |
598 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; | |
599 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy]; | |
600 }else{ | |
601 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0; | |
602 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
603 } | |
604 | |
605 if(IS_INTER(top_type)){ | |
606 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; | |
607 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
608 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
609 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
610 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
611 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
612 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
613 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
614 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
615 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
616 }else{ | |
617 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= | |
618 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
619 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
620 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; | |
621 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
622 } | |
623 | |
624 if(IS_INTER(topright_type)){ | |
625 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride; | |
626 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride; | |
627 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; | |
628 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy]; | |
629 }else{ | |
630 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0; | |
631 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
632 } | |
633 | |
634 //FIXME unify cleanup or sth | |
635 if(IS_INTER(left_type[0])){ | |
636 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; | |
637 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1; | |
638 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]]; | |
639 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1]]; | |
640 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
641 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)]; | |
642 }else{ | |
643 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]= | |
644 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0; | |
645 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
646 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
647 } | |
648 | |
649 if(IS_INTER(left_type[1])){ | |
650 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; | |
651 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1; | |
652 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[2]]; | |
653 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[3]]; | |
654 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
655 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)]; | |
656 }else{ | |
657 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]= | |
658 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0; | |
659 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
660 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
661 } | |
662 | |
2449 | 663 if(for_deblock) |
664 continue; | |
665 | |
1168 | 666 h->ref_cache[list][scan8[5 ]+1] = |
667 h->ref_cache[list][scan8[7 ]+1] = | |
668 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewher else) | |
669 h->ref_cache[list][scan8[4 ]] = | |
670 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; | |
671 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
672 *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]= | |
673 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewher else) | |
674 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= | |
675 *(uint32_t*)h->mv_cache [list][scan8[12]]= 0; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
676 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
677 if( h->pps.cabac ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
678 /* XXX beurk, Load mvd */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
679 if(IS_INTER(topleft_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
680 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
681 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
682 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
683 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 - 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
684 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
685 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
686 if(IS_INTER(top_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
687 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
688 *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
689 *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
690 *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
691 *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
692 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
693 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
694 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
695 *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
696 *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
697 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
698 if(IS_INTER(left_type[0])){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
699 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
700 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
701 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
702 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
703 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
704 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
705 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
706 if(IS_INTER(left_type[1])){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
707 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
708 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
709 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
710 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
711 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
712 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
713 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
714 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
715 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
716 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewher else) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
717 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
718 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 719 |
720 if(h->slice_type == B_TYPE){ | |
721 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
722 | |
723 if(IS_DIRECT(top_type)){ | |
724 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
725 }else if(IS_8X8(top_type)){ | |
726 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
727 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
728 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
729 }else{ | |
730 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
731 } | |
732 | |
733 //FIXME interlacing | |
734 if(IS_DIRECT(left_type[0])){ | |
735 h->direct_cache[scan8[0] - 1 + 0*8]= | |
736 h->direct_cache[scan8[0] - 1 + 2*8]= 1; | |
737 }else if(IS_8X8(left_type[0])){ | |
738 int b8_xy = h->mb2b8_xy[left_xy[0]] + 1; | |
739 h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[b8_xy]; | |
740 h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[b8_xy + h->b8_stride]; | |
741 }else{ | |
742 h->direct_cache[scan8[0] - 1 + 0*8]= | |
743 h->direct_cache[scan8[0] - 1 + 2*8]= 0; | |
744 } | |
745 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
746 } |
1168 | 747 } |
748 } | |
749 #endif | |
750 } | |
751 | |
752 static inline void write_back_intra_pred_mode(H264Context *h){ | |
753 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
754 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 755 |
756 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
757 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
758 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
759 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
760 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
761 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
762 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
763 } | |
764 | |
765 /** | |
766 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
767 */ | |
768 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
769 MpegEncContext * const s = &h->s; | |
770 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
771 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
772 int i; | |
773 | |
774 if(!(h->top_samples_available&0x8000)){ | |
775 for(i=0; i<4; i++){ | |
776 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
777 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
778 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 779 return -1; |
780 } else if(status){ | |
781 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
782 } | |
783 } | |
784 } | |
785 | |
786 if(!(h->left_samples_available&0x8000)){ | |
787 for(i=0; i<4; i++){ | |
788 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
789 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
790 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 791 return -1; |
792 } else if(status){ | |
793 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
794 } | |
795 } | |
796 } | |
797 | |
798 return 0; | |
799 } //FIXME cleanup like next | |
800 | |
801 /** | |
802 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
803 */ | |
804 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
805 MpegEncContext * const s = &h->s; | |
806 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
807 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
808 | |
2392 | 809 if(mode < 0 || mode > 6) { |
810 av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y); | |
2163 | 811 return -1; |
2392 | 812 } |
2163 | 813 |
1168 | 814 if(!(h->top_samples_available&0x8000)){ |
815 mode= top[ mode ]; | |
816 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
817 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); |
1168 | 818 return -1; |
819 } | |
820 } | |
821 | |
822 if(!(h->left_samples_available&0x8000)){ | |
823 mode= left[ mode ]; | |
824 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
825 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); |
1168 | 826 return -1; |
827 } | |
828 } | |
829 | |
830 return mode; | |
831 } | |
832 | |
833 /** | |
834 * gets the predicted intra4x4 prediction mode. | |
835 */ | |
836 static inline int pred_intra_mode(H264Context *h, int n){ | |
837 const int index8= scan8[n]; | |
838 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
839 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
840 const int min= FFMIN(left, top); | |
841 | |
1170 | 842 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 843 |
844 if(min<0) return DC_PRED; | |
845 else return min; | |
846 } | |
847 | |
848 static inline void write_back_non_zero_count(H264Context *h){ | |
849 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
850 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
851 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
852 h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[4+8*4]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
853 h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[5+8*4]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
854 h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[6+8*4]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
855 h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
856 h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[7+8*3]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
857 h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[7+8*2]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
858 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[7+8*1]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
859 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
860 h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[1+8*2]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
861 h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
862 h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[2+8*1]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
863 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
864 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[1+8*5]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
865 h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
866 h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[2+8*4]; |
1168 | 867 } |
868 | |
869 /** | |
870 * gets the predicted number of non zero coefficients. | |
871 * @param n block index | |
872 */ | |
873 static inline int pred_non_zero_count(H264Context *h, int n){ | |
874 const int index8= scan8[n]; | |
875 const int left= h->non_zero_count_cache[index8 - 1]; | |
876 const int top = h->non_zero_count_cache[index8 - 8]; | |
877 int i= left + top; | |
878 | |
879 if(i<64) i= (i+1)>>1; | |
880 | |
1170 | 881 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 882 |
883 return i&31; | |
884 } | |
885 | |
1169 | 886 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
887 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
888 | |
889 if(topright_ref != PART_NOT_AVAILABLE){ | |
890 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
891 return topright_ref; | |
892 }else{ | |
1170 | 893 tprintf("topright MV not available\n"); |
894 | |
1169 | 895 *C= h->mv_cache[list][ i - 8 - 1 ]; |
896 return h->ref_cache[list][ i - 8 - 1 ]; | |
897 } | |
898 } | |
899 | |
1168 | 900 /** |
901 * gets the predicted MV. | |
902 * @param n the block index | |
903 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
904 * @param mx the x component of the predicted motion vector | |
905 * @param my the y component of the predicted motion vector | |
906 */ | |
907 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
908 const int index8= scan8[n]; | |
909 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
910 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
911 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
912 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 913 const int16_t * C; |
914 int diagonal_ref, match_count; | |
915 | |
1168 | 916 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 917 |
1168 | 918 /* mv_cache |
919 B . . A T T T T | |
920 U . . L . . , . | |
921 U . . L . . . . | |
922 U . . L . . , . | |
923 . . . L . . . . | |
924 */ | |
1169 | 925 |
926 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
927 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref); | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
928 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 929 if(match_count > 1){ //most common |
930 *mx= mid_pred(A[0], B[0], C[0]); | |
931 *my= mid_pred(A[1], B[1], C[1]); | |
932 }else if(match_count==1){ | |
933 if(left_ref==ref){ | |
934 *mx= A[0]; | |
935 *my= A[1]; | |
936 }else if(top_ref==ref){ | |
937 *mx= B[0]; | |
938 *my= B[1]; | |
939 }else{ | |
940 *mx= C[0]; | |
941 *my= C[1]; | |
942 } | |
943 }else{ | |
944 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
945 *mx= A[0]; | |
946 *my= A[1]; | |
1168 | 947 }else{ |
948 *mx= mid_pred(A[0], B[0], C[0]); | |
949 *my= mid_pred(A[1], B[1], C[1]); | |
950 } | |
1169 | 951 } |
1168 | 952 |
1187 | 953 tprintf("pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list); |
1168 | 954 } |
955 | |
956 /** | |
957 * gets the directionally predicted 16x8 MV. | |
958 * @param n the block index | |
959 * @param mx the x component of the predicted motion vector | |
960 * @param my the y component of the predicted motion vector | |
961 */ | |
962 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
963 if(n==0){ | |
964 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
965 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
966 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
967 tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 968 |
969 if(top_ref == ref){ | |
970 *mx= B[0]; | |
971 *my= B[1]; | |
972 return; | |
973 } | |
974 }else{ | |
975 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
976 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
977 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
978 tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 979 |
980 if(left_ref == ref){ | |
981 *mx= A[0]; | |
982 *my= A[1]; | |
983 return; | |
984 } | |
985 } | |
986 | |
987 //RARE | |
988 pred_motion(h, n, 4, list, ref, mx, my); | |
989 } | |
990 | |
991 /** | |
992 * gets the directionally predicted 8x16 MV. | |
993 * @param n the block index | |
994 * @param mx the x component of the predicted motion vector | |
995 * @param my the y component of the predicted motion vector | |
996 */ | |
997 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
998 if(n==0){ | |
999 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1000 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
1001 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1002 tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1003 |
1004 if(left_ref == ref){ | |
1005 *mx= A[0]; | |
1006 *my= A[1]; | |
1007 return; | |
1008 } | |
1009 }else{ | |
1169 | 1010 const int16_t * C; |
1011 int diagonal_ref; | |
1012 | |
1013 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
1168 | 1014 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1015 tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 1016 |
1169 | 1017 if(diagonal_ref == ref){ |
1168 | 1018 *mx= C[0]; |
1019 *my= C[1]; | |
1020 return; | |
1021 } | |
1022 } | |
1023 | |
1024 //RARE | |
1025 pred_motion(h, n, 2, list, ref, mx, my); | |
1026 } | |
1027 | |
1028 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1029 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1030 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1031 | |
2392 | 1032 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1033 |
1034 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1035 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1036 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
1037 | |
1038 *mx = *my = 0; | |
1039 return; | |
1040 } | |
1041 | |
1042 pred_motion(h, 0, 4, 0, 0, mx, my); | |
1043 | |
1044 return; | |
1045 } | |
1046 | |
2396 | 1047 static inline void direct_dist_scale_factor(H264Context * const h){ |
1048 const int poc = h->s.current_picture_ptr->poc; | |
1049 const int poc1 = h->ref_list[1][0].poc; | |
1050 int i; | |
1051 for(i=0; i<h->ref_count[0]; i++){ | |
1052 int poc0 = h->ref_list[0][i].poc; | |
1053 int td = clip(poc1 - poc0, -128, 127); | |
1054 if(td == 0 /* FIXME || pic0 is a long-term ref */){ | |
1055 h->dist_scale_factor[i] = 256; | |
1056 }else{ | |
1057 int tb = clip(poc - poc0, -128, 127); | |
1058 int tx = (16384 + (ABS(td) >> 1)) / td; | |
1059 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023); | |
1060 } | |
1061 } | |
1062 } | |
1063 | |
1064 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1065 MpegEncContext * const s = &h->s; | |
1066 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1067 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1068 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1069 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1070 const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy]; | |
1071 const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy]; | |
1072 const int is_b8x8 = IS_8X8(*mb_type); | |
1073 int sub_mb_type; | |
1074 int i8, i4; | |
1075 | |
1076 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ | |
1077 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1078 * so we know exactly what block size to use */ | |
1079 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
1080 *mb_type = MB_TYPE_8x8; | |
1081 }else if(!is_b8x8 && (IS_16X16(mb_type_col) || IS_INTRA(mb_type_col))){ | |
1082 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
1083 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1084 }else{ | |
1085 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
1086 *mb_type = MB_TYPE_8x8; | |
1087 } | |
1088 if(!is_b8x8) | |
1089 *mb_type |= MB_TYPE_DIRECT2; | |
1090 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
1091 tprintf("mb_type = %08x, sub_mb_type = %08x, is_b8x8 = %d, mb_type_col = %08x\n", *mb_type, sub_mb_type, is_b8x8, mb_type_col); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
1092 |
2396 | 1093 if(h->direct_spatial_mv_pred){ |
1094 int ref[2]; | |
1095 int mv[2][2]; | |
1096 int list; | |
1097 | |
1098 /* ref = min(neighbors) */ | |
1099 for(list=0; list<2; list++){ | |
1100 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1101 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1102 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1103 if(refc == -2) | |
1104 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1105 ref[list] = refa; | |
1106 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1107 ref[list] = refb; | |
1108 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1109 ref[list] = refc; | |
1110 if(ref[list] < 0) | |
1111 ref[list] = -1; | |
1112 } | |
1113 | |
1114 if(ref[0] < 0 && ref[1] < 0){ | |
1115 ref[0] = ref[1] = 0; | |
1116 mv[0][0] = mv[0][1] = | |
1117 mv[1][0] = mv[1][1] = 0; | |
1118 }else{ | |
1119 for(list=0; list<2; list++){ | |
1120 if(ref[list] >= 0) | |
1121 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1122 else | |
1123 mv[list][0] = mv[list][1] = 0; | |
1124 } | |
1125 } | |
1126 | |
1127 if(ref[1] < 0){ | |
1128 *mb_type &= ~MB_TYPE_P0L1; | |
1129 sub_mb_type &= ~MB_TYPE_P0L1; | |
1130 }else if(ref[0] < 0){ | |
1131 *mb_type &= ~MB_TYPE_P0L0; | |
1132 sub_mb_type &= ~MB_TYPE_P0L0; | |
1133 } | |
1134 | |
1135 if(IS_16X16(*mb_type)){ | |
1136 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref[0], 1); | |
1137 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, ref[1], 1); | |
1138 if(!IS_INTRA(mb_type_col) && l1ref0[0] == 0 && | |
1139 ABS(l1mv0[0][0]) <= 1 && ABS(l1mv0[0][1]) <= 1){ | |
1140 if(ref[0] > 0) | |
1141 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1142 else | |
1143 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1144 if(ref[1] > 0) | |
1145 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1146 else | |
1147 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1148 }else{ | |
1149 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1150 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1151 } | |
1152 }else{ | |
1153 for(i8=0; i8<4; i8++){ | |
1154 const int x8 = i8&1; | |
1155 const int y8 = i8>>1; | |
1156 | |
1157 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1158 continue; | |
1159 h->sub_mb_type[i8] = sub_mb_type; | |
1160 | |
1161 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1162 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1163 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref[0], 1); | |
1164 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, ref[1], 1); | |
1165 | |
1166 /* col_zero_flag */ | |
1167 if(!IS_INTRA(mb_type_col) && l1ref0[x8 + y8*h->b8_stride] == 0){ | |
1168 for(i4=0; i4<4; i4++){ | |
1169 const int16_t *mv_col = l1mv0[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; | |
1170 if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){ | |
1171 if(ref[0] == 0) | |
1172 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1173 if(ref[1] == 0) | |
1174 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1175 } | |
1176 } | |
1177 } | |
1178 } | |
1179 } | |
1180 }else{ /* direct temporal mv pred */ | |
1181 /* FIXME assumes that L1ref0 used the same ref lists as current frame */ | |
1182 if(IS_16X16(*mb_type)){ | |
1183 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); | |
1184 if(IS_INTRA(mb_type_col)){ | |
1185 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1186 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1187 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1188 }else{ | |
1189 const int ref0 = l1ref0[0]; | |
1190 const int dist_scale_factor = h->dist_scale_factor[ref0]; | |
1191 const int16_t *mv_col = l1mv0[0]; | |
1192 int mv_l0[2]; | |
1193 mv_l0[0] = (dist_scale_factor * mv_col[0] + 128) >> 8; | |
1194 mv_l0[1] = (dist_scale_factor * mv_col[1] + 128) >> 8; | |
1195 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1); | |
1196 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4); | |
1197 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]), 4); | |
1198 } | |
1199 }else{ | |
1200 for(i8=0; i8<4; i8++){ | |
1201 const int x8 = i8&1; | |
1202 const int y8 = i8>>1; | |
1203 int ref0, dist_scale_factor; | |
1204 | |
1205 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1206 continue; | |
1207 h->sub_mb_type[i8] = sub_mb_type; | |
1208 if(IS_INTRA(mb_type_col)){ | |
1209 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1210 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1211 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1212 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1213 continue; | |
1214 } | |
1215 | |
1216 ref0 = l1ref0[x8 + y8*h->b8_stride]; | |
1217 dist_scale_factor = h->dist_scale_factor[ref0]; | |
1218 | |
1219 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1220 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1221 for(i4=0; i4<4; i4++){ | |
1222 const int16_t *mv_col = l1mv0[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; | |
1223 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; | |
1224 mv_l0[0] = (dist_scale_factor * mv_col[0] + 128) >> 8; | |
1225 mv_l0[1] = (dist_scale_factor * mv_col[1] + 128) >> 8; | |
1226 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = | |
1227 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1228 } | |
1229 } | |
1230 } | |
1231 } | |
1232 } | |
1233 | |
1168 | 1234 static inline void write_back_motion(H264Context *h, int mb_type){ |
1235 MpegEncContext * const s = &h->s; | |
1236 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1237 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1238 int list; | |
1239 | |
1240 for(list=0; list<2; list++){ | |
1241 int y; | |
1242 if((!IS_8X8(mb_type)) && !USES_LIST(mb_type, list)){ | |
1243 if(1){ //FIXME skip or never read if mb_type doesnt use it | |
1244 for(y=0; y<4; y++){ | |
1245 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= | |
1246 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= 0; | |
1247 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1248 if( h->pps.cabac ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1249 /* FIXME needed ? */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1250 for(y=0; y<4; y++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1251 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1252 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1253 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1254 } |
1168 | 1255 for(y=0; y<2; y++){ |
2365
b76a4977447a
Fixed typo which caused incorrect motion prediction in B-frames. patch by (Loren Merritt <lorenm ta u tod washington tod edu>)
michael
parents:
2336
diff
changeset
|
1256 *(uint16_t*)&s->current_picture.ref_index[list][b8_xy + y*h->b8_stride]= (LIST_NOT_USED&0xFF)*0x0101; |
1168 | 1257 } |
1258 } | |
2396 | 1259 continue; |
1168 | 1260 } |
1261 | |
1262 for(y=0; y<4; y++){ | |
1263 *(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]; | |
1264 *(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]; | |
1265 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1266 if( h->pps.cabac ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1267 for(y=0; y<4; y++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1268 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1269 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1270 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1271 } |
1168 | 1272 for(y=0; y<2; y++){ |
1273 s->current_picture.ref_index[list][b8_xy + 0 + y*h->b8_stride]= h->ref_cache[list][scan8[0]+0 + 16*y]; | |
1274 s->current_picture.ref_index[list][b8_xy + 1 + y*h->b8_stride]= h->ref_cache[list][scan8[0]+2 + 16*y]; | |
1275 } | |
1276 } | |
2396 | 1277 |
1278 if(h->slice_type == B_TYPE && h->pps.cabac){ | |
1279 if(IS_8X8(mb_type)){ | |
1280 h->direct_table[b8_xy+1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1281 h->direct_table[b8_xy+0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1282 h->direct_table[b8_xy+1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
1283 } | |
1284 } | |
1168 | 1285 } |
1286 | |
1287 /** | |
1288 * Decodes a network abstraction layer unit. | |
1289 * @param consumed is the number of bytes used as input | |
1290 * @param length is the length of the array | |
1291 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp ttailing? | |
1292 * @returns decoded bytes, might be src+1 if no escapes | |
1293 */ | |
1294 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1295 int i, si, di; | |
1296 uint8_t *dst; | |
1297 | |
1298 // src[0]&0x80; //forbidden bit | |
1299 h->nal_ref_idc= src[0]>>5; | |
1300 h->nal_unit_type= src[0]&0x1F; | |
1301 | |
1302 src++; length--; | |
1303 #if 0 | |
1304 for(i=0; i<length; i++) | |
1305 printf("%2X ", src[i]); | |
1306 #endif | |
1307 for(i=0; i+1<length; i+=2){ | |
1308 if(src[i]) continue; | |
1309 if(i>0 && src[i-1]==0) i--; | |
1310 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1311 if(src[i+2]!=3){ | |
1312 /* startcode, so we must be past the end */ | |
1313 length=i; | |
1314 } | |
1315 break; | |
1316 } | |
1317 } | |
1318 | |
1319 if(i>=length-1){ //no escaped 0 | |
1320 *dst_length= length; | |
1321 *consumed= length+1; //+1 for the header | |
1322 return src; | |
1323 } | |
1324 | |
1325 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1326 dst= h->rbsp_buffer; | |
1327 | |
1328 //printf("deoding esc\n"); | |
1329 si=di=0; | |
1330 while(si<length){ | |
1331 //remove escapes (very rare 1:2^22) | |
1332 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1333 if(src[si+2]==3){ //escape | |
1334 dst[di++]= 0; | |
1335 dst[di++]= 0; | |
1336 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1337 continue; |
1168 | 1338 }else //next start code |
1339 break; | |
1340 } | |
1341 | |
1342 dst[di++]= src[si++]; | |
1343 } | |
1344 | |
1345 *dst_length= di; | |
1346 *consumed= si + 1;//+1 for the header | |
1347 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1348 return dst; | |
1349 } | |
1350 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1351 #if 0 |
1168 | 1352 /** |
1353 * @param src the data which should be escaped | |
1354 * @param dst the target buffer, dst+1 == src is allowed as a special case | |
1355 * @param length the length of the src data | |
1356 * @param dst_length the length of the dst array | |
1357 * @returns length of escaped data in bytes or -1 if an error occured | |
1358 */ | |
1359 static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){ | |
1360 int i, escape_count, si, di; | |
1361 uint8_t *temp; | |
1362 | |
1363 assert(length>=0); | |
1364 assert(dst_length>0); | |
1365 | |
1366 dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type; | |
1367 | |
1368 if(length==0) return 1; | |
1369 | |
1370 escape_count= 0; | |
1371 for(i=0; i<length; i+=2){ | |
1372 if(src[i]) continue; | |
1373 if(i>0 && src[i-1]==0) | |
1374 i--; | |
1375 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1376 escape_count++; | |
1377 i+=2; | |
1378 } | |
1379 } | |
1380 | |
1381 if(escape_count==0){ | |
1382 if(dst+1 != src) | |
1383 memcpy(dst+1, src, length); | |
1384 return length + 1; | |
1385 } | |
1386 | |
1387 if(length + escape_count + 1> dst_length) | |
1388 return -1; | |
1389 | |
1390 //this should be damn rare (hopefully) | |
1391 | |
1392 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count); | |
1393 temp= h->rbsp_buffer; | |
1394 //printf("encoding esc\n"); | |
1395 | |
1396 si= 0; | |
1397 di= 0; | |
1398 while(si < length){ | |
1399 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1400 temp[di++]= 0; si++; | |
1401 temp[di++]= 0; si++; | |
1402 temp[di++]= 3; | |
1403 temp[di++]= src[si++]; | |
1404 } | |
1405 else | |
1406 temp[di++]= src[si++]; | |
1407 } | |
1408 memcpy(dst+1, temp, length+escape_count); | |
1409 | |
1410 assert(di == length+escape_count); | |
1411 | |
1412 return di + 1; | |
1413 } | |
1414 | |
1415 /** | |
1416 * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4 | |
1417 */ | |
1418 static void encode_rbsp_trailing(PutBitContext *pb){ | |
1419 int length; | |
1420 put_bits(pb, 1, 1); | |
1786 | 1421 length= (-put_bits_count(pb))&7; |
1168 | 1422 if(length) put_bits(pb, length, 0); |
1423 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1424 #endif |
1168 | 1425 |
1426 /** | |
1427 * identifies the exact end of the bitstream | |
1428 * @return the length of the trailing, or 0 if damaged | |
1429 */ | |
1430 static int decode_rbsp_trailing(uint8_t *src){ | |
1431 int v= *src; | |
1432 int r; | |
1433 | |
1170 | 1434 tprintf("rbsp trailing %X\n", v); |
1168 | 1435 |
1436 for(r=1; r<9; r++){ | |
1437 if(v&1) return r; | |
1438 v>>=1; | |
1439 } | |
1440 return 0; | |
1441 } | |
1442 | |
1443 /** | |
1444 * idct tranforms the 16 dc values and dequantize them. | |
1445 * @param qp quantization parameter | |
1446 */ | |
1447 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp){ | |
1448 const int qmul= dequant_coeff[qp][0]; | |
1449 #define stride 16 | |
1450 int i; | |
1451 int temp[16]; //FIXME check if this is a good idea | |
1452 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1453 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1454 | |
1455 //memset(block, 64, 2*256); | |
1456 //return; | |
1457 for(i=0; i<4; i++){ | |
1458 const int offset= y_offset[i]; | |
1459 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1460 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1461 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1462 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1463 | |
1464 temp[4*i+0]= z0+z3; | |
1465 temp[4*i+1]= z1+z2; | |
1466 temp[4*i+2]= z1-z2; | |
1467 temp[4*i+3]= z0-z3; | |
1468 } | |
1469 | |
1470 for(i=0; i<4; i++){ | |
1471 const int offset= x_offset[i]; | |
1472 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1473 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1474 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1475 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1476 | |
1477 block[stride*0 +offset]= ((z0 + z3)*qmul + 2)>>2; //FIXME think about merging this into decode_resdual | |
1478 block[stride*2 +offset]= ((z1 + z2)*qmul + 2)>>2; | |
1479 block[stride*8 +offset]= ((z1 - z2)*qmul + 2)>>2; | |
1480 block[stride*10+offset]= ((z0 - z3)*qmul + 2)>>2; | |
1481 } | |
1482 } | |
1483 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1484 #if 0 |
1168 | 1485 /** |
1486 * dct tranforms the 16 dc values. | |
1487 * @param qp quantization parameter ??? FIXME | |
1488 */ | |
1489 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1490 // const int qmul= dequant_coeff[qp][0]; | |
1491 int i; | |
1492 int temp[16]; //FIXME check if this is a good idea | |
1493 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1494 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1495 | |
1496 for(i=0; i<4; i++){ | |
1497 const int offset= y_offset[i]; | |
1498 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1499 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1500 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1501 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1502 | |
1503 temp[4*i+0]= z0+z3; | |
1504 temp[4*i+1]= z1+z2; | |
1505 temp[4*i+2]= z1-z2; | |
1506 temp[4*i+3]= z0-z3; | |
1507 } | |
1508 | |
1509 for(i=0; i<4; i++){ | |
1510 const int offset= x_offset[i]; | |
1511 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1512 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1513 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1514 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1515 | |
1516 block[stride*0 +offset]= (z0 + z3)>>1; | |
1517 block[stride*2 +offset]= (z1 + z2)>>1; | |
1518 block[stride*8 +offset]= (z1 - z2)>>1; | |
1519 block[stride*10+offset]= (z0 - z3)>>1; | |
1520 } | |
1521 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1522 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1523 |
1168 | 1524 #undef xStride |
1525 #undef stride | |
1526 | |
1527 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp){ | |
1528 const int qmul= dequant_coeff[qp][0]; | |
1529 const int stride= 16*2; | |
1530 const int xStride= 16; | |
1531 int a,b,c,d,e; | |
1532 | |
1533 a= block[stride*0 + xStride*0]; | |
1534 b= block[stride*0 + xStride*1]; | |
1535 c= block[stride*1 + xStride*0]; | |
1536 d= block[stride*1 + xStride*1]; | |
1537 | |
1538 e= a-b; | |
1539 a= a+b; | |
1540 b= c-d; | |
1541 c= c+d; | |
1542 | |
1543 block[stride*0 + xStride*0]= ((a+c)*qmul + 0)>>1; | |
1544 block[stride*0 + xStride*1]= ((e+b)*qmul + 0)>>1; | |
1545 block[stride*1 + xStride*0]= ((a-c)*qmul + 0)>>1; | |
1546 block[stride*1 + xStride*1]= ((e-b)*qmul + 0)>>1; | |
1547 } | |
1548 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1549 #if 0 |
1168 | 1550 static void chroma_dc_dct_c(DCTELEM *block){ |
1551 const int stride= 16*2; | |
1552 const int xStride= 16; | |
1553 int a,b,c,d,e; | |
1554 | |
1555 a= block[stride*0 + xStride*0]; | |
1556 b= block[stride*0 + xStride*1]; | |
1557 c= block[stride*1 + xStride*0]; | |
1558 d= block[stride*1 + xStride*1]; | |
1559 | |
1560 e= a-b; | |
1561 a= a+b; | |
1562 b= c-d; | |
1563 c= c+d; | |
1564 | |
1565 block[stride*0 + xStride*0]= (a+c); | |
1566 block[stride*0 + xStride*1]= (e+b); | |
1567 block[stride*1 + xStride*0]= (a-c); | |
1568 block[stride*1 + xStride*1]= (e-b); | |
1569 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1570 #endif |
1168 | 1571 |
1572 /** | |
1573 * gets the chroma qp. | |
1574 */ | |
1575 static inline int get_chroma_qp(H264Context *h, int qscale){ | |
1576 | |
1577 return chroma_qp[clip(qscale + h->pps.chroma_qp_index_offset, 0, 51)]; | |
1578 } | |
1579 | |
1580 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1581 #if 0 |
1168 | 1582 static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){ |
1583 int i; | |
1584 //FIXME try int temp instead of block | |
1585 | |
1586 for(i=0; i<4; i++){ | |
1587 const int d0= src1[0 + i*stride] - src2[0 + i*stride]; | |
1588 const int d1= src1[1 + i*stride] - src2[1 + i*stride]; | |
1589 const int d2= src1[2 + i*stride] - src2[2 + i*stride]; | |
1590 const int d3= src1[3 + i*stride] - src2[3 + i*stride]; | |
1591 const int z0= d0 + d3; | |
1592 const int z3= d0 - d3; | |
1593 const int z1= d1 + d2; | |
1594 const int z2= d1 - d2; | |
1595 | |
1596 block[0 + 4*i]= z0 + z1; | |
1597 block[1 + 4*i]= 2*z3 + z2; | |
1598 block[2 + 4*i]= z0 - z1; | |
1599 block[3 + 4*i]= z3 - 2*z2; | |
1600 } | |
1601 | |
1602 for(i=0; i<4; i++){ | |
1603 const int z0= block[0*4 + i] + block[3*4 + i]; | |
1604 const int z3= block[0*4 + i] - block[3*4 + i]; | |
1605 const int z1= block[1*4 + i] + block[2*4 + i]; | |
1606 const int z2= block[1*4 + i] - block[2*4 + i]; | |
1607 | |
1608 block[0*4 + i]= z0 + z1; | |
1609 block[1*4 + i]= 2*z3 + z2; | |
1610 block[2*4 + i]= z0 - z1; | |
1611 block[3*4 + i]= z3 - 2*z2; | |
1612 } | |
1613 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1614 #endif |
1168 | 1615 |
1616 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, iam not sure, its very close | |
1617 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away) | |
1618 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){ | |
1619 int i; | |
1620 const int * const quant_table= quant_coeff[qscale]; | |
1621 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1622 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1623 const unsigned int threshold2= (threshold1<<1); | |
1624 int last_non_zero; | |
1625 | |
1626 if(seperate_dc){ | |
1627 if(qscale<=18){ | |
1628 //avoid overflows | |
1629 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1630 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1631 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1632 | |
1633 int level= block[0]*quant_coeff[qscale+18][0]; | |
1634 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1635 if(level>0){ | |
1636 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1637 block[0]= level; | |
1638 }else{ | |
1639 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1640 block[0]= -level; | |
1641 } | |
1642 // last_non_zero = i; | |
1643 }else{ | |
1644 block[0]=0; | |
1645 } | |
1646 }else{ | |
1647 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1648 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1649 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1650 | |
1651 int level= block[0]*quant_table[0]; | |
1652 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1653 if(level>0){ | |
1654 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
1655 block[0]= level; | |
1656 }else{ | |
1657 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
1658 block[0]= -level; | |
1659 } | |
1660 // last_non_zero = i; | |
1661 }else{ | |
1662 block[0]=0; | |
1663 } | |
1664 } | |
1665 last_non_zero= 0; | |
1666 i=1; | |
1667 }else{ | |
1668 last_non_zero= -1; | |
1669 i=0; | |
1670 } | |
1671 | |
1672 for(; i<16; i++){ | |
1673 const int j= scantable[i]; | |
1674 int level= block[j]*quant_table[j]; | |
1675 | |
1676 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
1677 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
1678 if(((unsigned)(level+threshold1))>threshold2){ | |
1679 if(level>0){ | |
1680 level= (bias + level)>>QUANT_SHIFT; | |
1681 block[j]= level; | |
1682 }else{ | |
1683 level= (bias - level)>>QUANT_SHIFT; | |
1684 block[j]= -level; | |
1685 } | |
1686 last_non_zero = i; | |
1687 }else{ | |
1688 block[j]=0; | |
1689 } | |
1690 } | |
1691 | |
1692 return last_non_zero; | |
1693 } | |
1694 | |
1695 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
1696 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
1697 ((uint32_t*)(src+0*stride))[0]= a; | |
1698 ((uint32_t*)(src+1*stride))[0]= a; | |
1699 ((uint32_t*)(src+2*stride))[0]= a; | |
1700 ((uint32_t*)(src+3*stride))[0]= a; | |
1701 } | |
1702 | |
1703 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
1704 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
1705 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
1706 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
1707 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
1708 } | |
1709 | |
1710 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1711 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
1712 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
1713 | |
1714 ((uint32_t*)(src+0*stride))[0]= | |
1715 ((uint32_t*)(src+1*stride))[0]= | |
1716 ((uint32_t*)(src+2*stride))[0]= | |
1717 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1718 } | |
1719 | |
1720 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1721 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
1722 | |
1723 ((uint32_t*)(src+0*stride))[0]= | |
1724 ((uint32_t*)(src+1*stride))[0]= | |
1725 ((uint32_t*)(src+2*stride))[0]= | |
1726 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1727 } | |
1728 | |
1729 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1730 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
1731 | |
1732 ((uint32_t*)(src+0*stride))[0]= | |
1733 ((uint32_t*)(src+1*stride))[0]= | |
1734 ((uint32_t*)(src+2*stride))[0]= | |
1735 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1736 } | |
1737 | |
1738 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1739 ((uint32_t*)(src+0*stride))[0]= | |
1740 ((uint32_t*)(src+1*stride))[0]= | |
1741 ((uint32_t*)(src+2*stride))[0]= | |
1742 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; | |
1743 } | |
1744 | |
1745 | |
1746 #define LOAD_TOP_RIGHT_EDGE\ | |
1747 const int t4= topright[0];\ | |
1748 const int t5= topright[1];\ | |
1749 const int t6= topright[2];\ | |
1750 const int t7= topright[3];\ | |
1751 | |
1752 #define LOAD_LEFT_EDGE\ | |
1753 const int l0= src[-1+0*stride];\ | |
1754 const int l1= src[-1+1*stride];\ | |
1755 const int l2= src[-1+2*stride];\ | |
1756 const int l3= src[-1+3*stride];\ | |
1757 | |
1758 #define LOAD_TOP_EDGE\ | |
1759 const int t0= src[ 0-1*stride];\ | |
1760 const int t1= src[ 1-1*stride];\ | |
1761 const int t2= src[ 2-1*stride];\ | |
1762 const int t3= src[ 3-1*stride];\ | |
1763 | |
1764 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
1765 const int lt= src[-1-1*stride]; | |
1766 LOAD_TOP_EDGE | |
1767 LOAD_LEFT_EDGE | |
1768 | |
1769 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; | |
1770 src[0+2*stride]= | |
1771 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; | |
1772 src[0+1*stride]= | |
1773 src[1+2*stride]= | |
1774 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; | |
1775 src[0+0*stride]= | |
1776 src[1+1*stride]= | |
1777 src[2+2*stride]= | |
1778 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
1779 src[1+0*stride]= | |
1780 src[2+1*stride]= | |
1781 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
1782 src[2+0*stride]= | |
1783 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1784 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 1785 } |
1168 | 1786 |
1787 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
1788 LOAD_TOP_EDGE | |
1789 LOAD_TOP_RIGHT_EDGE | |
1790 // LOAD_LEFT_EDGE | |
1791 | |
1792 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
1793 src[1+0*stride]= | |
1794 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
1795 src[2+0*stride]= | |
1796 src[1+1*stride]= | |
1797 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
1798 src[3+0*stride]= | |
1799 src[2+1*stride]= | |
1800 src[1+2*stride]= | |
1801 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
1802 src[3+1*stride]= | |
1803 src[2+2*stride]= | |
1804 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
1805 src[3+2*stride]= | |
1806 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
1807 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 1808 } |
1168 | 1809 |
1810 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
1811 const int lt= src[-1-1*stride]; | |
1812 LOAD_TOP_EDGE | |
1813 LOAD_LEFT_EDGE | |
1814 const __attribute__((unused)) int unu= l3; | |
1815 | |
1816 src[0+0*stride]= | |
1817 src[1+2*stride]=(lt + t0 + 1)>>1; | |
1818 src[1+0*stride]= | |
1819 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
1820 src[2+0*stride]= | |
1821 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
1822 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
1823 src[0+1*stride]= | |
1824 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
1825 src[1+1*stride]= | |
1826 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
1827 src[2+1*stride]= | |
1828 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1829 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1830 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
1831 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 1832 } |
1168 | 1833 |
1834 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
1835 LOAD_TOP_EDGE | |
1836 LOAD_TOP_RIGHT_EDGE | |
1837 const __attribute__((unused)) int unu= t7; | |
1838 | |
1839 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
1840 src[1+0*stride]= | |
1841 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
1842 src[2+0*stride]= | |
1843 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
1844 src[3+0*stride]= | |
1845 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
1846 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
1847 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1848 src[1+1*stride]= | |
1849 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1850 src[2+1*stride]= | |
1851 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
1852 src[3+1*stride]= | |
1853 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
1854 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 1855 } |
1168 | 1856 |
1857 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
1858 LOAD_LEFT_EDGE | |
1859 | |
1860 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
1861 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1862 src[2+0*stride]= | |
1863 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
1864 src[3+0*stride]= | |
1865 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1866 src[2+1*stride]= | |
1867 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
1868 src[3+1*stride]= | |
1869 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
1870 src[3+2*stride]= | |
1871 src[1+3*stride]= | |
1872 src[0+3*stride]= | |
1873 src[2+2*stride]= | |
1874 src[2+3*stride]= | |
1875 src[3+3*stride]=l3; | |
1282 | 1876 } |
1168 | 1877 |
1878 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ | |
1879 const int lt= src[-1-1*stride]; | |
1880 LOAD_TOP_EDGE | |
1881 LOAD_LEFT_EDGE | |
1882 const __attribute__((unused)) int unu= t3; | |
1883 | |
1884 src[0+0*stride]= | |
1885 src[2+1*stride]=(lt + l0 + 1)>>1; | |
1886 src[1+0*stride]= | |
1887 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
1888 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
1889 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1890 src[0+1*stride]= | |
1891 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
1892 src[1+1*stride]= | |
1893 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
1894 src[0+2*stride]= | |
1895 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
1896 src[1+2*stride]= | |
1897 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1898 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
1899 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 1900 } |
1168 | 1901 |
1902 static void pred16x16_vertical_c(uint8_t *src, int stride){ | |
1903 int i; | |
1904 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
1905 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
1906 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
1907 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
1908 | |
1909 for(i=0; i<16; i++){ | |
1910 ((uint32_t*)(src+i*stride))[0]= a; | |
1911 ((uint32_t*)(src+i*stride))[1]= b; | |
1912 ((uint32_t*)(src+i*stride))[2]= c; | |
1913 ((uint32_t*)(src+i*stride))[3]= d; | |
1914 } | |
1915 } | |
1916 | |
1917 static void pred16x16_horizontal_c(uint8_t *src, int stride){ | |
1918 int i; | |
1919 | |
1920 for(i=0; i<16; i++){ | |
1921 ((uint32_t*)(src+i*stride))[0]= | |
1922 ((uint32_t*)(src+i*stride))[1]= | |
1923 ((uint32_t*)(src+i*stride))[2]= | |
1924 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
1925 } | |
1926 } | |
1927 | |
1928 static void pred16x16_dc_c(uint8_t *src, int stride){ | |
1929 int i, dc=0; | |
1930 | |
1931 for(i=0;i<16; i++){ | |
1932 dc+= src[-1+i*stride]; | |
1933 } | |
1934 | |
1935 for(i=0;i<16; i++){ | |
1936 dc+= src[i-stride]; | |
1937 } | |
1938 | |
1939 dc= 0x01010101*((dc + 16)>>5); | |
1940 | |
1941 for(i=0; i<16; i++){ | |
1942 ((uint32_t*)(src+i*stride))[0]= | |
1943 ((uint32_t*)(src+i*stride))[1]= | |
1944 ((uint32_t*)(src+i*stride))[2]= | |
1945 ((uint32_t*)(src+i*stride))[3]= dc; | |
1946 } | |
1947 } | |
1948 | |
1949 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
1950 int i, dc=0; | |
1951 | |
1952 for(i=0;i<16; i++){ | |
1953 dc+= src[-1+i*stride]; | |
1954 } | |
1955 | |
1956 dc= 0x01010101*((dc + 8)>>4); | |
1957 | |
1958 for(i=0; i<16; i++){ | |
1959 ((uint32_t*)(src+i*stride))[0]= | |
1960 ((uint32_t*)(src+i*stride))[1]= | |
1961 ((uint32_t*)(src+i*stride))[2]= | |
1962 ((uint32_t*)(src+i*stride))[3]= dc; | |
1963 } | |
1964 } | |
1965 | |
1966 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
1967 int i, dc=0; | |
1968 | |
1969 for(i=0;i<16; i++){ | |
1970 dc+= src[i-stride]; | |
1971 } | |
1972 dc= 0x01010101*((dc + 8)>>4); | |
1973 | |
1974 for(i=0; i<16; i++){ | |
1975 ((uint32_t*)(src+i*stride))[0]= | |
1976 ((uint32_t*)(src+i*stride))[1]= | |
1977 ((uint32_t*)(src+i*stride))[2]= | |
1978 ((uint32_t*)(src+i*stride))[3]= dc; | |
1979 } | |
1980 } | |
1981 | |
1982 static void pred16x16_128_dc_c(uint8_t *src, int stride){ | |
1983 int i; | |
1984 | |
1985 for(i=0; i<16; i++){ | |
1986 ((uint32_t*)(src+i*stride))[0]= | |
1987 ((uint32_t*)(src+i*stride))[1]= | |
1988 ((uint32_t*)(src+i*stride))[2]= | |
1989 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
1990 } | |
1991 } | |
1992 | |
1234 | 1993 static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){ |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1994 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1995 int a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1996 uint8_t *cm = cropTbl + MAX_NEG_CROP; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1997 const uint8_t * const src0 = src+7-stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1998 const uint8_t *src1 = src+8*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1999 const uint8_t *src2 = src1-2*stride; // == src+6*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2000 int H = src0[1] - src0[-1]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2001 int V = src1[0] - src2[ 0]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2002 for(k=2; k<=8; ++k) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2003 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2004 H += k*(src0[k] - src0[-k]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2005 V += k*(src1[0] - src2[ 0]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2006 } |
1234 | 2007 if(svq3){ |
2008 H = ( 5*(H/4) ) / 16; | |
2009 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2010 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2011 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2012 i = H; H = V; V = i; |
1234 | 2013 }else{ |
2014 H = ( 5*H+32 ) >> 6; | |
2015 V = ( 5*V+32 ) >> 6; | |
2016 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2017 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2018 a = 16*(src1[0] + src2[16] + 1) - 7*(V+H); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2019 for(j=16; j>0; --j) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2020 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2021 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2022 for(i=-16; i<0; i+=4) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2023 src[16+i] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2024 src[17+i] = cm[ (b+ H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2025 src[18+i] = cm[ (b+2*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2026 src[19+i] = cm[ (b+3*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2027 b += 4*H; |
1168 | 2028 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2029 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2030 } |
1168 | 2031 } |
2032 | |
1234 | 2033 static void pred16x16_plane_c(uint8_t *src, int stride){ |
2034 pred16x16_plane_compat_c(src, stride, 0); | |
2035 } | |
2036 | |
1168 | 2037 static void pred8x8_vertical_c(uint8_t *src, int stride){ |
2038 int i; | |
2039 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2040 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2041 | |
2042 for(i=0; i<8; i++){ | |
2043 ((uint32_t*)(src+i*stride))[0]= a; | |
2044 ((uint32_t*)(src+i*stride))[1]= b; | |
2045 } | |
2046 } | |
2047 | |
2048 static void pred8x8_horizontal_c(uint8_t *src, int stride){ | |
2049 int i; | |
2050 | |
2051 for(i=0; i<8; i++){ | |
2052 ((uint32_t*)(src+i*stride))[0]= | |
2053 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2054 } | |
2055 } | |
2056 | |
2057 static void pred8x8_128_dc_c(uint8_t *src, int stride){ | |
2058 int i; | |
2059 | |
2060 for(i=0; i<4; i++){ | |
2061 ((uint32_t*)(src+i*stride))[0]= | |
2062 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; | |
2063 } | |
2064 for(i=4; i<8; i++){ | |
2065 ((uint32_t*)(src+i*stride))[0]= | |
2066 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; | |
2067 } | |
2068 } | |
2069 | |
2070 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2071 int i; | |
2072 int dc0, dc2; | |
2073 | |
2074 dc0=dc2=0; | |
2075 for(i=0;i<4; i++){ | |
2076 dc0+= src[-1+i*stride]; | |
2077 dc2+= src[-1+(i+4)*stride]; | |
2078 } | |
2079 dc0= 0x01010101*((dc0 + 2)>>2); | |
2080 dc2= 0x01010101*((dc2 + 2)>>2); | |
2081 | |
2082 for(i=0; i<4; i++){ | |
2083 ((uint32_t*)(src+i*stride))[0]= | |
2084 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2085 } | |
2086 for(i=4; i<8; i++){ | |
2087 ((uint32_t*)(src+i*stride))[0]= | |
2088 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2089 } | |
2090 } | |
2091 | |
2092 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2093 int i; | |
2094 int dc0, dc1; | |
2095 | |
2096 dc0=dc1=0; | |
2097 for(i=0;i<4; i++){ | |
2098 dc0+= src[i-stride]; | |
2099 dc1+= src[4+i-stride]; | |
2100 } | |
2101 dc0= 0x01010101*((dc0 + 2)>>2); | |
2102 dc1= 0x01010101*((dc1 + 2)>>2); | |
2103 | |
2104 for(i=0; i<4; i++){ | |
2105 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2106 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2107 } | |
2108 for(i=4; i<8; i++){ | |
2109 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2110 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2111 } | |
2112 } | |
2113 | |
2114 | |
2115 static void pred8x8_dc_c(uint8_t *src, int stride){ | |
2116 int i; | |
2117 int dc0, dc1, dc2, dc3; | |
2118 | |
2119 dc0=dc1=dc2=0; | |
2120 for(i=0;i<4; i++){ | |
2121 dc0+= src[-1+i*stride] + src[i-stride]; | |
2122 dc1+= src[4+i-stride]; | |
2123 dc2+= src[-1+(i+4)*stride]; | |
2124 } | |
2125 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2126 dc0= 0x01010101*((dc0 + 4)>>3); | |
2127 dc1= 0x01010101*((dc1 + 2)>>2); | |
2128 dc2= 0x01010101*((dc2 + 2)>>2); | |
2129 | |
2130 for(i=0; i<4; i++){ | |
2131 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2132 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2133 } | |
2134 for(i=4; i<8; i++){ | |
2135 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2136 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2137 } | |
2138 } | |
2139 | |
2140 static void pred8x8_plane_c(uint8_t *src, int stride){ | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2141 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2142 int a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2143 uint8_t *cm = cropTbl + MAX_NEG_CROP; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2144 const uint8_t * const src0 = src+3-stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2145 const uint8_t *src1 = src+4*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2146 const uint8_t *src2 = src1-2*stride; // == src+2*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2147 int H = src0[1] - src0[-1]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2148 int V = src1[0] - src2[ 0]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2149 for(k=2; k<=4; ++k) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2150 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2151 H += k*(src0[k] - src0[-k]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2152 V += k*(src1[0] - src2[ 0]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2153 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2154 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2155 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2156 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2157 a = 16*(src1[0] + src2[8]+1) - 3*(V+H); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2158 for(j=8; j>0; --j) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2159 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2160 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2161 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2162 src[1] = cm[ (b+ H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2163 src[2] = cm[ (b+2*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2164 src[3] = cm[ (b+3*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2165 src[4] = cm[ (b+4*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2166 src[5] = cm[ (b+5*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2167 src[6] = cm[ (b+6*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2168 src[7] = cm[ (b+7*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2169 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2170 } |
1168 | 2171 } |
2172 | |
2173 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, | |
2174 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2175 int src_x_offset, int src_y_offset, | |
2176 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2177 MpegEncContext * const s = &h->s; | |
2178 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
2179 const int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; | |
2180 const int luma_xy= (mx&3) + ((my&3)<<2); | |
2181 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*s->linesize; | |
2182 uint8_t * src_cb= pic->data[1] + (mx>>3) + (my>>3)*s->uvlinesize; | |
2183 uint8_t * src_cr= pic->data[2] + (mx>>3) + (my>>3)*s->uvlinesize; | |
2184 int extra_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; //FIXME increase edge?, IMHO not worth it | |
2185 int extra_height= extra_width; | |
2186 int emu=0; | |
2187 const int full_mx= mx>>2; | |
2188 const int full_my= my>>2; | |
2189 | |
2190 assert(pic->data[0]); | |
2191 | |
2192 if(mx&7) extra_width -= 3; | |
2193 if(my&7) extra_height -= 3; | |
2194 | |
2195 if( full_mx < 0-extra_width | |
2196 || full_my < 0-extra_height | |
2197 || full_mx + 16/*FIXME*/ > s->width + extra_width | |
2198 || full_my + 16/*FIXME*/ > s->height + extra_height){ | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1282
diff
changeset
|
2199 ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*s->linesize, s->linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, s->width, s->height); |
1168 | 2200 src_y= s->edge_emu_buffer + 2 + 2*s->linesize; |
2201 emu=1; | |
2202 } | |
2203 | |
2204 qpix_op[luma_xy](dest_y, src_y, s->linesize); //FIXME try variable height perhaps? | |
2205 if(!square){ | |
2206 qpix_op[luma_xy](dest_y + delta, src_y + delta, s->linesize); | |
2207 } | |
2208 | |
2209 if(s->flags&CODEC_FLAG_GRAY) return; | |
2210 | |
2211 if(emu){ | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1282
diff
changeset
|
2212 ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), s->width>>1, s->height>>1); |
1168 | 2213 src_cb= s->edge_emu_buffer; |
2214 } | |
2215 chroma_op(dest_cb, src_cb, s->uvlinesize, chroma_height, mx&7, my&7); | |
2216 | |
2217 if(emu){ | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1282
diff
changeset
|
2218 ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), s->width>>1, s->height>>1); |
1168 | 2219 src_cr= s->edge_emu_buffer; |
2220 } | |
2221 chroma_op(dest_cr, src_cr, s->uvlinesize, chroma_height, mx&7, my&7); | |
2222 } | |
2223 | |
2415 | 2224 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2225 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2226 int x_offset, int y_offset, | |
2227 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2228 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2229 int list0, int list1){ | |
2230 MpegEncContext * const s = &h->s; | |
2231 qpel_mc_func *qpix_op= qpix_put; | |
2232 h264_chroma_mc_func chroma_op= chroma_put; | |
2233 | |
2234 dest_y += 2*x_offset + 2*y_offset*s-> linesize; | |
2235 dest_cb += x_offset + y_offset*s->uvlinesize; | |
2236 dest_cr += x_offset + y_offset*s->uvlinesize; | |
2237 x_offset += 8*s->mb_x; | |
2238 y_offset += 8*s->mb_y; | |
2239 | |
2240 if(list0){ | |
1169 | 2241 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2242 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2243 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2244 qpix_op, chroma_op); | |
2245 | |
2246 qpix_op= qpix_avg; | |
2247 chroma_op= chroma_avg; | |
2248 } | |
2249 | |
2250 if(list1){ | |
1169 | 2251 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2252 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2253 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2254 qpix_op, chroma_op); | |
2255 } | |
2256 } | |
2257 | |
2415 | 2258 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2259 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2260 int x_offset, int y_offset, | |
2261 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2262 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2263 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2264 int list0, int list1){ | |
2265 MpegEncContext * const s = &h->s; | |
2266 | |
2267 dest_y += 2*x_offset + 2*y_offset*s-> linesize; | |
2268 dest_cb += x_offset + y_offset*s->uvlinesize; | |
2269 dest_cr += x_offset + y_offset*s->uvlinesize; | |
2270 x_offset += 8*s->mb_x; | |
2271 y_offset += 8*s->mb_y; | |
2272 | |
2273 if(list0 && list1){ | |
2274 /* don't optimize for luma-only case, since B-frames usually | |
2275 * use implicit weights => chroma too. */ | |
2276 uint8_t *tmp_cb = s->obmc_scratchpad; | |
2277 uint8_t *tmp_cr = tmp_cb + 8*s->uvlinesize; | |
2278 uint8_t *tmp_y = tmp_cr + 8*s->uvlinesize; | |
2279 int refn0 = h->ref_cache[0][ scan8[n] ]; | |
2280 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2281 | |
2282 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2283 dest_y, dest_cb, dest_cr, | |
2284 x_offset, y_offset, qpix_put, chroma_put); | |
2285 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2286 tmp_y, tmp_cb, tmp_cr, | |
2287 x_offset, y_offset, qpix_put, chroma_put); | |
2288 | |
2289 if(h->use_weight == 2){ | |
2290 int weight0 = h->implicit_weight[refn0][refn1]; | |
2291 int weight1 = 64 - weight0; | |
2292 luma_weight_avg( dest_y, tmp_y, s-> linesize, 5, weight0, weight1, 0, 0); | |
2293 chroma_weight_avg(dest_cb, tmp_cb, s->uvlinesize, 5, weight0, weight1, 0, 0); | |
2294 chroma_weight_avg(dest_cr, tmp_cr, s->uvlinesize, 5, weight0, weight1, 0, 0); | |
2295 }else{ | |
2296 luma_weight_avg(dest_y, tmp_y, s->linesize, h->luma_log2_weight_denom, | |
2297 h->luma_weight[0][refn0], h->luma_weight[1][refn1], | |
2298 h->luma_offset[0][refn0], h->luma_offset[1][refn1]); | |
2299 chroma_weight_avg(dest_cb, tmp_cb, s->uvlinesize, h->chroma_log2_weight_denom, | |
2300 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], | |
2301 h->chroma_offset[0][refn0][0], h->chroma_offset[1][refn1][0]); | |
2302 chroma_weight_avg(dest_cr, tmp_cr, s->uvlinesize, h->chroma_log2_weight_denom, | |
2303 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], | |
2304 h->chroma_offset[0][refn0][1], h->chroma_offset[1][refn1][1]); | |
2305 } | |
2306 }else{ | |
2307 int list = list1 ? 1 : 0; | |
2308 int refn = h->ref_cache[list][ scan8[n] ]; | |
2309 Picture *ref= &h->ref_list[list][refn]; | |
2310 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2311 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2312 qpix_put, chroma_put); | |
2313 | |
2314 luma_weight_op(dest_y, s->linesize, h->luma_log2_weight_denom, | |
2315 h->luma_weight[list][refn], h->luma_offset[list][refn]); | |
2316 if(h->use_weight_chroma){ | |
2317 chroma_weight_op(dest_cb, s->uvlinesize, h->chroma_log2_weight_denom, | |
2318 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); | |
2319 chroma_weight_op(dest_cr, s->uvlinesize, h->chroma_log2_weight_denom, | |
2320 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); | |
2321 } | |
2322 } | |
2323 } | |
2324 | |
2325 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2326 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2327 int x_offset, int y_offset, | |
2328 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2329 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2330 h264_weight_func *weight_op, h264_biweight_func *weight_avg, | |
2331 int list0, int list1){ | |
2332 if((h->use_weight==2 && list0 && list1 | |
2333 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2334 || h->use_weight==1) | |
2335 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2336 x_offset, y_offset, qpix_put, chroma_put, | |
2337 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2338 else | |
2339 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2340 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2341 } | |
2342 | |
1168 | 2343 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2344 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2345 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2346 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2347 MpegEncContext * const s = &h->s; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
2348 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2349 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2350 | |
2351 assert(IS_INTER(mb_type)); | |
2352 | |
2353 if(IS_16X16(mb_type)){ | |
2354 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2355 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2356 &weight_op[0], &weight_avg[0], |
1168 | 2357 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2358 }else if(IS_16X8(mb_type)){ | |
2359 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2360 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2361 &weight_op[1], &weight_avg[1], |
1168 | 2362 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2363 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
2364 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2365 &weight_op[1], &weight_avg[1], |
1168 | 2366 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2367 }else if(IS_8X16(mb_type)){ | |
2368 mc_part(h, 0, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 0, 0, | |
2369 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 2370 &weight_op[2], &weight_avg[2], |
1168 | 2371 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2372 mc_part(h, 4, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 4, 0, | |
2373 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 2374 &weight_op[2], &weight_avg[2], |
1168 | 2375 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2376 }else{ | |
2377 int i; | |
2378 | |
2379 assert(IS_8X8(mb_type)); | |
2380 | |
2381 for(i=0; i<4; i++){ | |
2382 const int sub_mb_type= h->sub_mb_type[i]; | |
2383 const int n= 4*i; | |
2384 int x_offset= (i&1)<<2; | |
2385 int y_offset= (i&2)<<1; | |
2386 | |
2387 if(IS_SUB_8X8(sub_mb_type)){ | |
2388 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2389 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 2390 &weight_op[3], &weight_avg[3], |
1168 | 2391 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2392 }else if(IS_SUB_8X4(sub_mb_type)){ | |
2393 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2394 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 2395 &weight_op[4], &weight_avg[4], |
1168 | 2396 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2397 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
2398 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 2399 &weight_op[4], &weight_avg[4], |
1168 | 2400 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2401 }else if(IS_SUB_4X8(sub_mb_type)){ | |
2402 mc_part(h, n , 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2403 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 2404 &weight_op[5], &weight_avg[5], |
1168 | 2405 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2406 mc_part(h, n+1, 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, | |
2407 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 2408 &weight_op[5], &weight_avg[5], |
1168 | 2409 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2410 }else{ | |
2411 int j; | |
2412 assert(IS_SUB_4X4(sub_mb_type)); | |
2413 for(j=0; j<4; j++){ | |
2414 int sub_x_offset= x_offset + 2*(j&1); | |
2415 int sub_y_offset= y_offset + (j&2); | |
2416 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
2417 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 2418 &weight_op[6], &weight_avg[6], |
1168 | 2419 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2420 } | |
2421 } | |
2422 } | |
2423 } | |
2424 } | |
2425 | |
2426 static void decode_init_vlc(H264Context *h){ | |
2427 static int done = 0; | |
2428 | |
2429 if (!done) { | |
2430 int i; | |
2431 done = 1; | |
2432 | |
2433 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, | |
2434 &chroma_dc_coeff_token_len [0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2435 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 2436 |
2437 for(i=0; i<4; i++){ | |
2438 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, | |
2439 &coeff_token_len [i][0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2440 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 2441 } |
2442 | |
2443 for(i=0; i<3; i++){ | |
2444 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
2445 &chroma_dc_total_zeros_len [i][0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2446 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 2447 } |
2448 for(i=0; i<15; i++){ | |
2449 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, | |
2450 &total_zeros_len [i][0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2451 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 2452 } |
2453 | |
2454 for(i=0; i<6; i++){ | |
2455 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, | |
2456 &run_len [i][0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2457 &run_bits[i][0], 1, 1, 1); |
1168 | 2458 } |
2459 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, | |
2460 &run_len [6][0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2461 &run_bits[6][0], 1, 1, 1); |
1168 | 2462 } |
2463 } | |
2464 | |
2465 /** | |
2466 * Sets the intra prediction function pointers. | |
2467 */ | |
2468 static void init_pred_ptrs(H264Context *h){ | |
2469 // MpegEncContext * const s = &h->s; | |
2470 | |
2471 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
2472 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
2473 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
2474 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
2475 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
2476 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
2477 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
2478 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
2479 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
2480 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
2481 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
2482 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
2483 | |
2484 h->pred8x8[DC_PRED8x8 ]= pred8x8_dc_c; | |
2485 h->pred8x8[VERT_PRED8x8 ]= pred8x8_vertical_c; | |
2486 h->pred8x8[HOR_PRED8x8 ]= pred8x8_horizontal_c; | |
2487 h->pred8x8[PLANE_PRED8x8 ]= pred8x8_plane_c; | |
2488 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; | |
2489 h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c; | |
2490 h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c; | |
2491 | |
2492 h->pred16x16[DC_PRED8x8 ]= pred16x16_dc_c; | |
2493 h->pred16x16[VERT_PRED8x8 ]= pred16x16_vertical_c; | |
2494 h->pred16x16[HOR_PRED8x8 ]= pred16x16_horizontal_c; | |
2495 h->pred16x16[PLANE_PRED8x8 ]= pred16x16_plane_c; | |
2496 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; | |
2497 h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c; | |
2498 h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c; | |
2499 } | |
2500 | |
2501 static void free_tables(H264Context *h){ | |
2502 av_freep(&h->intra4x4_pred_mode); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2503 av_freep(&h->chroma_pred_mode_table); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2504 av_freep(&h->cbp_table); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2505 av_freep(&h->mvd_table[0]); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2506 av_freep(&h->mvd_table[1]); |
2396 | 2507 av_freep(&h->direct_table); |
1168 | 2508 av_freep(&h->non_zero_count); |
2509 av_freep(&h->slice_table_base); | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2510 av_freep(&h->top_border); |
1168 | 2511 h->slice_table= NULL; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2512 |
1168 | 2513 av_freep(&h->mb2b_xy); |
2514 av_freep(&h->mb2b8_xy); | |
2415 | 2515 |
2516 av_freep(&h->s.obmc_scratchpad); | |
1168 | 2517 } |
2518 | |
2519 /** | |
2520 * allocates tables. | |
2521 * needs widzh/height | |
2522 */ | |
2523 static int alloc_tables(H264Context *h){ | |
2524 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
2525 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
1168 | 2526 int x,y; |
2527 | |
2528 CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t)) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2529 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2530 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
1168 | 2531 CHECKED_ALLOCZ(h->slice_table_base , big_mb_num * sizeof(uint8_t)) |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2532 CHECKED_ALLOCZ(h->top_border , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 2533 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 2534 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2535 if( h->pps.cabac ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2536 CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t)) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2537 CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2538 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 2539 CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t)); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2540 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2541 |
1168 | 2542 memset(h->slice_table_base, -1, big_mb_num * sizeof(uint8_t)); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
2543 h->slice_table= h->slice_table_base + s->mb_stride + 1; |
1168 | 2544 |
2545 CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint16_t)); | |
2546 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint16_t)); | |
2547 for(y=0; y<s->mb_height; y++){ | |
2548 for(x=0; x<s->mb_width; x++){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
2549 const int mb_xy= x + y*s->mb_stride; |
1168 | 2550 const int b_xy = 4*x + 4*y*h->b_stride; |
2551 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2552 | |
2553 h->mb2b_xy [mb_xy]= b_xy; | |
2554 h->mb2b8_xy[mb_xy]= b8_xy; | |
2555 } | |
2556 } | |
2415 | 2557 |
2417 | 2558 s->obmc_scratchpad = NULL; |
2559 | |
1168 | 2560 return 0; |
2561 fail: | |
2562 free_tables(h); | |
2563 return -1; | |
2564 } | |
2565 | |
2566 static void common_init(H264Context *h){ | |
2567 MpegEncContext * const s = &h->s; | |
2568 | |
2569 s->width = s->avctx->width; | |
2570 s->height = s->avctx->height; | |
2571 s->codec_id= s->avctx->codec->id; | |
2572 | |
2573 init_pred_ptrs(h); | |
2574 | |
1698 | 2575 s->unrestricted_mv=1; |
1168 | 2576 s->decode=1; //FIXME |
2577 } | |
2578 | |
2579 static int decode_init(AVCodecContext *avctx){ | |
2580 H264Context *h= avctx->priv_data; | |
2581 MpegEncContext * const s = &h->s; | |
2582 | |
1892 | 2583 MPV_decode_defaults(s); |
2584 | |
1168 | 2585 s->avctx = avctx; |
2586 common_init(h); | |
2587 | |
2588 s->out_format = FMT_H264; | |
2589 s->workaround_bugs= avctx->workaround_bugs; | |
2590 | |
2591 // set defaults | |
2592 // s->decode_mb= ff_h263_decode_mb; | |
2593 s->low_delay= 1; | |
2594 avctx->pix_fmt= PIX_FMT_YUV420P; | |
2595 | |
2596 decode_init_vlc(h); | |
2597 | |
2384 | 2598 if(avctx->codec_tag != 0x31637661 && avctx->codec_tag != 0x31435641) // avc1 |
2227 | 2599 h->is_avc = 0; |
2600 else { | |
2601 if((avctx->extradata_size == 0) || (avctx->extradata == NULL)) { | |
2602 av_log(avctx, AV_LOG_ERROR, "AVC codec requires avcC data\n"); | |
2603 return -1; | |
2604 } | |
2605 h->is_avc = 1; | |
2606 h->got_avcC = 0; | |
2607 } | |
2608 | |
1168 | 2609 return 0; |
2610 } | |
2611 | |
2612 static void frame_start(H264Context *h){ | |
2613 MpegEncContext * const s = &h->s; | |
2614 int i; | |
2615 | |
2616 MPV_frame_start(s, s->avctx); | |
2617 ff_er_frame_start(s); | |
2618 | |
2619 assert(s->linesize && s->uvlinesize); | |
2620 | |
2621 for(i=0; i<16; i++){ | |
2622 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3); | |
2623 h->chroma_subblock_offset[i]= 2*((scan8[i] - scan8[0])&7) + 2*s->uvlinesize*((scan8[i] - scan8[0])>>3); | |
2624 } | |
2625 for(i=0; i<4; i++){ | |
2626 h->block_offset[16+i]= | |
2627 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3); | |
2628 } | |
2629 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2630 /* can't be in alloc_tables because linesize isn't known there. |
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2631 * FIXME: redo bipred weight to not require extra buffer? */ |
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2632 if(!s->obmc_scratchpad) |
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2633 s->obmc_scratchpad = av_malloc(16*s->linesize + 2*8*s->uvlinesize); |
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2634 |
1168 | 2635 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2636 } | |
2637 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2638 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2639 MpegEncContext * const s = &h->s; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2640 int i; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2641 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2642 src_y -= linesize; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2643 src_cb -= uvlinesize; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2644 src_cr -= uvlinesize; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2645 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2646 h->left_border[0]= h->top_border[s->mb_x][15]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2647 for(i=1; i<17; i++){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2648 h->left_border[i]= src_y[15+i* linesize]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2649 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2650 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2651 *(uint64_t*)(h->top_border[s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2652 *(uint64_t*)(h->top_border[s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2653 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2654 if(!(s->flags&CODEC_FLAG_GRAY)){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2655 h->left_border[17 ]= h->top_border[s->mb_x][16+7]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2656 h->left_border[17+9]= h->top_border[s->mb_x][24+7]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2657 for(i=1; i<9; i++){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2658 h->left_border[i+17 ]= src_cb[7+i*uvlinesize]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2659 h->left_border[i+17+9]= src_cr[7+i*uvlinesize]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2660 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2661 *(uint64_t*)(h->top_border[s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2662 *(uint64_t*)(h->top_border[s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2663 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2664 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2665 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2666 static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2667 MpegEncContext * const s = &h->s; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2668 int temp8, i; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2669 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2670 int deblock_left = (s->mb_x > 0); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2671 int deblock_top = (s->mb_y > 0); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2672 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2673 src_y -= linesize + 1; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2674 src_cb -= uvlinesize + 1; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2675 src_cr -= uvlinesize + 1; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2676 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2677 #define XCHG(a,b,t,xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2678 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2679 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2680 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2681 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2682 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2683 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2684 for(i = !deblock_top; i<17; i++){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2685 XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2686 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2687 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2688 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2689 if(deblock_top){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2690 XCHG(*(uint64_t*)(h->top_border[s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2691 XCHG(*(uint64_t*)(h->top_border[s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2692 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2693 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2694 if(!(s->flags&CODEC_FLAG_GRAY)){ |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2695 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2696 for(i = !deblock_top; i<9; i++){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2697 XCHG(h->left_border[i+17 ], src_cb[i*uvlinesize], temp8, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2698 XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2699 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2700 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2701 if(deblock_top){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2702 XCHG(*(uint64_t*)(h->top_border[s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2703 XCHG(*(uint64_t*)(h->top_border[s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2704 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2705 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2706 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2707 |
1168 | 2708 static void hl_decode_mb(H264Context *h){ |
2709 MpegEncContext * const s = &h->s; | |
2710 const int mb_x= s->mb_x; | |
2711 const int mb_y= s->mb_y; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
2712 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 2713 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2714 uint8_t *dest_y, *dest_cb, *dest_cr; | |
2715 int linesize, uvlinesize /*dct_offset*/; | |
2716 int i; | |
2717 | |
2718 if(!s->decode) | |
2719 return; | |
2720 | |
2721 if(s->mb_skiped){ | |
2722 } | |
2723 | |
2724 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
2725 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
2726 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
2727 | |
2728 if (h->mb_field_decoding_flag) { | |
2729 linesize = s->linesize * 2; | |
2730 uvlinesize = s->uvlinesize * 2; | |
2731 if(mb_y&1){ //FIXME move out of this func? | |
2732 dest_y -= s->linesize*15; | |
2733 dest_cb-= s->linesize*7; | |
2734 dest_cr-= s->linesize*7; | |
2735 } | |
2736 } else { | |
2737 linesize = s->linesize; | |
2738 uvlinesize = s->uvlinesize; | |
2739 // dct_offset = s->linesize * 16; | |
2740 } | |
2741 | |
2742 if(IS_INTRA(mb_type)){ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2743 if(h->deblocking_filter) |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2744 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2745 |
1168 | 2746 if(!(s->flags&CODEC_FLAG_GRAY)){ |
2747 h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize); | |
2748 h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize); | |
2749 } | |
2750 | |
2751 if(IS_INTRA4x4(mb_type)){ | |
2752 if(!s->encoding){ | |
2753 for(i=0; i<16; i++){ | |
2754 uint8_t * const ptr= dest_y + h->block_offset[i]; | |
2383 | 2755 uint8_t *topright; |
1168 | 2756 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ]; |
2757 int tr; | |
2758 | |
2383 | 2759 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){ |
2760 const int topright_avail= (h->topright_samples_available<<i)&0x8000; | |
2761 assert(mb_y || linesize <= h->block_offset[i]); | |
2762 if(!topright_avail){ | |
2763 tr= ptr[3 - linesize]*0x01010101; | |
2764 topright= (uint8_t*) &tr; | |
2765 }else if(i==5 && h->deblocking_filter){ | |
2766 tr= *(uint32_t*)h->top_border[mb_x+1]; | |
2767 topright= (uint8_t*) &tr; | |
2768 }else | |
2769 topright= ptr + 4 - linesize; | |
2770 }else | |
2771 topright= NULL; | |
1168 | 2772 |
2773 h->pred4x4[ dir ](ptr, topright, linesize); | |
1234 | 2774 if(h->non_zero_count_cache[ scan8[i] ]){ |
2775 if(s->codec_id == CODEC_ID_H264) | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
2776 s->dsp.h264_idct_add(ptr, h->mb + i*16, linesize); |
1234 | 2777 else |
2778 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0); | |
2779 } | |
1168 | 2780 } |
2781 } | |
2782 }else{ | |
2783 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); | |
1234 | 2784 if(s->codec_id == CODEC_ID_H264) |
2785 h264_luma_dc_dequant_idct_c(h->mb, s->qscale); | |
2786 else | |
2787 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale); | |
1168 | 2788 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2789 if(h->deblocking_filter) |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2790 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); |
1234 | 2791 }else if(s->codec_id == CODEC_ID_H264){ |
1168 | 2792 hl_motion(h, dest_y, dest_cb, dest_cr, |
2793 s->dsp.put_h264_qpel_pixels_tab, s->dsp.put_h264_chroma_pixels_tab, | |
2415 | 2794 s->dsp.avg_h264_qpel_pixels_tab, s->dsp.avg_h264_chroma_pixels_tab, |
2795 s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab); | |
1168 | 2796 } |
2797 | |
2798 | |
2799 if(!IS_INTRA4x4(mb_type)){ | |
1250 | 2800 if(s->codec_id == CODEC_ID_H264){ |
2801 for(i=0; i<16; i++){ | |
2802 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below | |
2803 uint8_t * const ptr= dest_y + h->block_offset[i]; | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
2804 s->dsp.h264_idct_add(ptr, h->mb + i*16, linesize); |
1250 | 2805 } |
2806 } | |
2807 }else{ | |
2808 for(i=0; i<16; i++){ | |
2809 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below | |
2810 uint8_t * const ptr= dest_y + h->block_offset[i]; | |
1234 | 2811 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1250 | 2812 } |
1168 | 2813 } |
2814 } | |
2815 } | |
2816 | |
2817 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
2818 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp); | |
2819 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp); | |
1250 | 2820 if(s->codec_id == CODEC_ID_H264){ |
2821 for(i=16; i<16+4; i++){ | |
2822 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2823 uint8_t * const ptr= dest_cb + h->block_offset[i]; | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
2824 s->dsp.h264_idct_add(ptr, h->mb + i*16, uvlinesize); |
1250 | 2825 } |
2826 } | |
2827 for(i=20; i<20+4; i++){ | |
2828 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2829 uint8_t * const ptr= dest_cr + h->block_offset[i]; | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
2830 s->dsp.h264_idct_add(ptr, h->mb + i*16, uvlinesize); |
1250 | 2831 } |
1168 | 2832 } |
1250 | 2833 }else{ |
2834 for(i=16; i<16+4; i++){ | |
2835 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2836 uint8_t * const ptr= dest_cb + h->block_offset[i]; | |
1234 | 2837 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2); |
1250 | 2838 } |
2839 } | |
2840 for(i=20; i<20+4; i++){ | |
2841 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2842 uint8_t * const ptr= dest_cr + h->block_offset[i]; | |
2843 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2); | |
2844 } | |
1168 | 2845 } |
2846 } | |
2847 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2848 if(h->deblocking_filter) { |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2849 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize); |
2449 | 2850 fill_caches(h, mb_type, 1); //FIXME dont fill stuff which isnt used by filter_mb |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2851 filter_mb(h, mb_x, mb_y, dest_y, dest_cb, dest_cr); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2852 } |
1168 | 2853 } |
2854 | |
2855 /** | |
2856 * fills the default_ref_list. | |
2857 */ | |
2858 static int fill_default_ref_list(H264Context *h){ | |
2859 MpegEncContext * const s = &h->s; | |
2860 int i; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2861 int smallest_poc_greater_than_current = -1; |
1168 | 2862 Picture sorted_short_ref[16]; |
2863 | |
2864 if(h->slice_type==B_TYPE){ | |
2865 int out_i; | |
2866 int limit= -1; | |
2867 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2868 /* sort frame according to poc in B slice */ |
1168 | 2869 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2870 int best_i=-1; | |
2255
507690ff49a2
assertion when playing AVC/H.264 streams fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2254
diff
changeset
|
2871 int best_poc=INT_MAX; |
1168 | 2872 |
2873 for(i=0; i<h->short_ref_count; i++){ | |
2874 const int poc= h->short_ref[i]->poc; | |
2875 if(poc > limit && poc < best_poc){ | |
2876 best_poc= poc; | |
2877 best_i= i; | |
2878 } | |
2879 } | |
2880 | |
2881 assert(best_i != -1); | |
2882 | |
2883 limit= best_poc; | |
2884 sorted_short_ref[out_i]= *h->short_ref[best_i]; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2885 tprintf("sorted poc: %d->%d poc:%d fn:%d\n", best_i, out_i, sorted_short_ref[out_i].poc, sorted_short_ref[out_i].frame_num); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2886 if (-1 == smallest_poc_greater_than_current) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2887 if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2888 smallest_poc_greater_than_current = out_i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2889 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2890 } |
1168 | 2891 } |
2892 } | |
2893 | |
2894 if(s->picture_structure == PICT_FRAME){ | |
2895 if(h->slice_type==B_TYPE){ | |
2896 int list; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2897 tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2898 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2899 // find the largest poc |
1168 | 2900 for(list=0; list<2; list++){ |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2901 int index = 0; |
2447 | 2902 int j= -99; |
2903 int step= list ? -1 : 1; | |
2904 | |
2905 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
2906 while(j<0 || j>= h->short_ref_count){ | |
2907 step = -step; | |
2908 j= smallest_poc_greater_than_current + (step>>1); | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2909 } |
2447 | 2910 if(sorted_short_ref[j].reference != 3) continue; |
2911 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
2912 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 2913 } |
2914 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2915 for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2916 if(h->long_ref[i] == NULL) continue; |
1168 | 2917 if(h->long_ref[i]->reference != 3) continue; |
2918 | |
2919 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
2920 h->default_ref_list[ list ][index++].pic_id= i;; | |
2921 } | |
2922 | |
2447 | 2923 if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){ |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2924 // swap the two first elements of L1 when |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2925 // L0 and L1 are identical |
1168 | 2926 Picture temp= h->default_ref_list[1][0]; |
2927 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2928 h->default_ref_list[1][0] = temp; | |
2929 } | |
2930 | |
2931 if(index < h->ref_count[ list ]) | |
2932 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
2933 } | |
2934 }else{ | |
2935 int index=0; | |
2936 for(i=0; i<h->short_ref_count && index < h->ref_count[0]; i++){ | |
2937 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit | |
2938 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
2939 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
2940 } | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2941 for(i = 0; i < 16 && index < h->ref_count[0]; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2942 if(h->long_ref[i] == NULL) continue; |
1168 | 2943 if(h->long_ref[i]->reference != 3) continue; |
2944 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
2945 h->default_ref_list[0][index++].pic_id= i;; | |
2946 } | |
2947 if(index < h->ref_count[0]) | |
2948 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
2949 } | |
2950 }else{ //FIELD | |
2951 if(h->slice_type==B_TYPE){ | |
2952 }else{ | |
2953 //FIXME second field balh | |
2954 } | |
2955 } | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2956 #ifdef TRACE |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2957 for (i=0; i<h->ref_count[0]; i++) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2958 tprintf("List0: %s fn:%d 0x%p\n", (h->default_ref_list[0][i].long_ref ? "LT" : "ST"), h->default_ref_list[0][i].pic_id, h->default_ref_list[0][i].data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2959 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2960 if(h->slice_type==B_TYPE){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2961 for (i=0; i<h->ref_count[1]; i++) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2962 tprintf("List1: %s fn:%d 0x%p\n", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[0][i].data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2963 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2964 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2965 #endif |
1168 | 2966 return 0; |
2967 } | |
2968 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2969 static void print_short_term(H264Context *h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2970 static void print_long_term(H264Context *h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2971 |
1168 | 2972 static int decode_ref_pic_list_reordering(H264Context *h){ |
2973 MpegEncContext * const s = &h->s; | |
2974 int list; | |
2975 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2976 print_short_term(h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2977 print_long_term(h); |
1168 | 2978 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move beofre func |
2979 | |
2980 for(list=0; list<2; list++){ | |
2981 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); | |
2982 | |
2983 if(get_bits1(&s->gb)){ | |
2984 int pred= h->curr_pic_num; | |
2985 int index; | |
2986 | |
2987 for(index=0; ; index++){ | |
2988 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); | |
2989 int pic_id; | |
2990 int i; | |
2991 | |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
2992 if(reordering_of_pic_nums_idc==3) |
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
2993 break; |
1168 | 2994 |
2995 if(index >= h->ref_count[list]){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
2996 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 2997 return -1; |
2998 } | |
2999 | |
3000 if(reordering_of_pic_nums_idc<3){ | |
3001 if(reordering_of_pic_nums_idc<2){ | |
3002 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; | |
3003 | |
3004 if(abs_diff_pic_num >= h->max_pic_num){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3005 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3006 return -1; |
3007 } | |
3008 | |
3009 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3010 else pred+= abs_diff_pic_num; | |
3011 pred &= h->max_pic_num - 1; | |
3012 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3013 for(i= h->ref_count[list]-1; i>=0; i--){ |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3014 if(h->ref_list[list][i].data[0] != NULL && h->ref_list[list][i].pic_id == pred && h->ref_list[list][i].long_ref==0) // ignore non existing pictures by testing data[0] pointer |
1168 | 3015 break; |
3016 } | |
3017 }else{ | |
3018 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
3019 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3020 for(i= h->ref_count[list]-1; i>=0; i--){ |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3021 if(h->ref_list[list][i].pic_id == pic_id && h->ref_list[list][i].long_ref==1) // no need to ignore non existing pictures as non existing pictures have long_ref==0 |
1168 | 3022 break; |
3023 } | |
3024 } | |
3025 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3026 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3027 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3028 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3029 } else if (i != index) /* this test is not necessary, it is only an optimisation to skip double copy of Picture structure in this case */ { |
1168 | 3030 Picture tmp= h->ref_list[list][i]; |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3031 if (i < index) { |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3032 i = h->ref_count[list]; |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3033 } |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3034 for(; i > index; i--){ |
1168 | 3035 h->ref_list[list][i]= h->ref_list[list][i-1]; |
3036 } | |
3037 h->ref_list[list][index]= tmp; | |
3038 } | |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3039 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3040 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3041 return -1; |
3042 } | |
3043 } | |
3044 } | |
3045 | |
3046 if(h->slice_type!=B_TYPE) break; | |
3047 } | |
2396 | 3048 |
3049 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) | |
3050 direct_dist_scale_factor(h); | |
1168 | 3051 return 0; |
3052 } | |
3053 | |
3054 static int pred_weight_table(H264Context *h){ | |
3055 MpegEncContext * const s = &h->s; | |
3056 int list, i; | |
2415 | 3057 int luma_def, chroma_def; |
1168 | 3058 |
2415 | 3059 h->use_weight= 0; |
3060 h->use_weight_chroma= 0; | |
1168 | 3061 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
3062 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 3063 luma_def = 1<<h->luma_log2_weight_denom; |
3064 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 3065 |
3066 for(list=0; list<2; list++){ | |
3067 for(i=0; i<h->ref_count[list]; i++){ | |
3068 int luma_weight_flag, chroma_weight_flag; | |
3069 | |
3070 luma_weight_flag= get_bits1(&s->gb); | |
3071 if(luma_weight_flag){ | |
3072 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
3073 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 3074 if( h->luma_weight[list][i] != luma_def |
3075 || h->luma_offset[list][i] != 0) | |
3076 h->use_weight= 1; | |
3077 }else{ | |
3078 h->luma_weight[list][i]= luma_def; | |
3079 h->luma_offset[list][i]= 0; | |
1168 | 3080 } |
3081 | |
3082 chroma_weight_flag= get_bits1(&s->gb); | |
3083 if(chroma_weight_flag){ | |
3084 int j; | |
3085 for(j=0; j<2; j++){ | |
3086 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
3087 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 3088 if( h->chroma_weight[list][i][j] != chroma_def |
3089 || h->chroma_offset[list][i][j] != 0) | |
3090 h->use_weight_chroma= 1; | |
3091 } | |
3092 }else{ | |
3093 int j; | |
3094 for(j=0; j<2; j++){ | |
3095 h->chroma_weight[list][i][j]= chroma_def; | |
3096 h->chroma_offset[list][i][j]= 0; | |
1168 | 3097 } |
3098 } | |
3099 } | |
3100 if(h->slice_type != B_TYPE) break; | |
3101 } | |
2415 | 3102 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 3103 return 0; |
3104 } | |
3105 | |
2415 | 3106 static void implicit_weight_table(H264Context *h){ |
3107 MpegEncContext * const s = &h->s; | |
3108 int ref0, ref1; | |
3109 int cur_poc = s->current_picture_ptr->poc; | |
3110 | |
3111 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
3112 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
3113 h->use_weight= 0; | |
3114 h->use_weight_chroma= 0; | |
3115 return; | |
3116 } | |
3117 | |
3118 h->use_weight= 2; | |
3119 h->use_weight_chroma= 2; | |
3120 h->luma_log2_weight_denom= 5; | |
3121 h->chroma_log2_weight_denom= 5; | |
3122 | |
3123 /* FIXME: MBAFF */ | |
3124 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
3125 int poc0 = h->ref_list[0][ref0].poc; | |
3126 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
3127 int poc1 = h->ref_list[0][ref1].poc; | |
3128 int td = clip(poc1 - poc0, -128, 127); | |
3129 if(td){ | |
3130 int tb = clip(cur_poc - poc0, -128, 127); | |
3131 int tx = (16384 + (ABS(td) >> 1)) / td; | |
3132 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; | |
3133 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
3134 h->implicit_weight[ref0][ref1] = 32; | |
3135 else | |
3136 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
3137 }else | |
3138 h->implicit_weight[ref0][ref1] = 32; | |
3139 } | |
3140 } | |
3141 } | |
3142 | |
1168 | 3143 /** |
2392 | 3144 * instantaneous decoder refresh. |
1168 | 3145 */ |
3146 static void idr(H264Context *h){ | |
2409 | 3147 int i,j; |
3148 | |
3149 #define CHECK_DELAY(pic) \ | |
3150 for(j = 0; h->delayed_pic[j]; j++) \ | |
3151 if(pic == h->delayed_pic[j]){ \ | |
3152 pic->reference=1; \ | |
3153 break; \ | |
3154 } | |
1168 | 3155 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3156 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3157 if (h->long_ref[i] != NULL) { |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3158 h->long_ref[i]->reference=0; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3159 CHECK_DELAY(h->long_ref[i]); |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3160 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3161 } |
1168 | 3162 } |
3163 h->long_ref_count=0; | |
3164 | |
3165 for(i=0; i<h->short_ref_count; i++){ | |
3166 h->short_ref[i]->reference=0; | |
2409 | 3167 CHECK_DELAY(h->short_ref[i]); |
1168 | 3168 h->short_ref[i]= NULL; |
3169 } | |
3170 h->short_ref_count=0; | |
3171 } | |
2409 | 3172 #undef CHECK_DELAY |
1168 | 3173 |
3174 /** | |
3175 * | |
3176 * @return the removed picture or NULL if an error occures | |
3177 */ | |
3178 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 3179 MpegEncContext * const s = &h->s; |
1168 | 3180 int i; |
3181 | |
1169 | 3182 if(s->avctx->debug&FF_DEBUG_MMCO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3183 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
1169 | 3184 |
1168 | 3185 for(i=0; i<h->short_ref_count; i++){ |
3186 Picture *pic= h->short_ref[i]; | |
1169 | 3187 if(s->avctx->debug&FF_DEBUG_MMCO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3188 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 3189 if(pic->frame_num == frame_num){ |
3190 h->short_ref[i]= NULL; | |
3191 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
3192 h->short_ref_count--; | |
3193 return pic; | |
3194 } | |
3195 } | |
3196 return NULL; | |
3197 } | |
3198 | |
3199 /** | |
3200 * | |
3201 * @return the removed picture or NULL if an error occures | |
3202 */ | |
3203 static Picture * remove_long(H264Context *h, int i){ | |
3204 Picture *pic; | |
3205 | |
3206 pic= h->long_ref[i]; | |
3207 h->long_ref[i]= NULL; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3208 if(pic) h->long_ref_count--; |
1168 | 3209 |
3210 return pic; | |
3211 } | |
3212 | |
3213 /** | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3214 * print short term list |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3215 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3216 static void print_short_term(H264Context *h) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3217 uint32_t i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3218 if(h->s.avctx->debug&FF_DEBUG_MMCO) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3219 av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n"); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3220 for(i=0; i<h->short_ref_count; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3221 Picture *pic= h->short_ref[i]; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3222 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3223 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3224 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3225 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3226 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3227 /** |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3228 * print long term list |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3229 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3230 static void print_long_term(H264Context *h) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3231 uint32_t i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3232 if(h->s.avctx->debug&FF_DEBUG_MMCO) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3233 av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n"); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3234 for(i = 0; i < 16; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3235 Picture *pic= h->long_ref[i]; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3236 if (pic) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3237 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3238 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3239 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3240 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3241 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3242 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3243 /** |
1168 | 3244 * Executes the reference picture marking (memory management control operations). |
3245 */ | |
3246 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
3247 MpegEncContext * const s = &h->s; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3248 int i, j; |
1168 | 3249 int current_is_long=0; |
3250 Picture *pic; | |
3251 | |
3252 if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3253 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
1168 | 3254 |
3255 for(i=0; i<mmco_count; i++){ | |
3256 if(s->avctx->debug&FF_DEBUG_MMCO) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3257 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index); |
1168 | 3258 |
3259 switch(mmco[i].opcode){ | |
3260 case MMCO_SHORT2UNUSED: | |
3261 pic= remove_short(h, mmco[i].short_frame_num); | |
3262 if(pic==NULL) return -1; | |
3263 pic->reference= 0; | |
3264 break; | |
3265 case MMCO_SHORT2LONG: | |
3266 pic= remove_long(h, mmco[i].long_index); | |
3267 if(pic) pic->reference=0; | |
3268 | |
3269 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); | |
3270 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3271 h->long_ref_count++; |
1168 | 3272 break; |
3273 case MMCO_LONG2UNUSED: | |
3274 pic= remove_long(h, mmco[i].long_index); | |
3275 if(pic==NULL) return -1; | |
3276 pic->reference= 0; | |
3277 break; | |
3278 case MMCO_LONG: | |
3279 pic= remove_long(h, mmco[i].long_index); | |
3280 if(pic) pic->reference=0; | |
3281 | |
3282 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; | |
3283 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
3284 h->long_ref_count++; | |
3285 | |
3286 current_is_long=1; | |
3287 break; | |
3288 case MMCO_SET_MAX_LONG: | |
3289 assert(mmco[i].long_index <= 16); | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3290 // just remove the long term which index is greater than new max |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3291 for(j = mmco[i].long_index; j<16; j++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3292 pic = remove_long(h, j); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3293 if (pic) pic->reference=0; |
1168 | 3294 } |
3295 break; | |
3296 case MMCO_RESET: | |
3297 while(h->short_ref_count){ | |
3298 pic= remove_short(h, h->short_ref[0]->frame_num); | |
3299 pic->reference=0; | |
3300 } | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3301 for(j = 0; j < 16; j++) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3302 pic= remove_long(h, j); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3303 if(pic) pic->reference=0; |
1168 | 3304 } |
3305 break; | |
3306 default: assert(0); | |
3307 } | |
3308 } | |
3309 | |
3310 if(!current_is_long){ | |
3311 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
3312 if(pic){ | |
3313 pic->reference=0; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3314 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 3315 } |
3316 | |
3317 if(h->short_ref_count) | |
1169 | 3318 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
3319 | |
3320 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 3321 h->short_ref[0]->long_ref=0; |
3322 h->short_ref_count++; | |
3323 } | |
3324 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3325 print_short_term(h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3326 print_long_term(h); |
1168 | 3327 return 0; |
3328 } | |
3329 | |
3330 static int decode_ref_pic_marking(H264Context *h){ | |
3331 MpegEncContext * const s = &h->s; | |
3332 int i; | |
3333 | |
3334 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields | |
3335 s->broken_link= get_bits1(&s->gb) -1; | |
3336 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
3337 if(h->mmco[0].long_index == -1) | |
3338 h->mmco_index= 0; | |
3339 else{ | |
3340 h->mmco[0].opcode= MMCO_LONG; | |
3341 h->mmco_index= 1; | |
3342 } | |
3343 }else{ | |
3344 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
3345 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 3346 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
3347 | |
3348 h->mmco[i].opcode= opcode; | |
3349 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
3350 h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(&s->gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields | |
3351 /* if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){ | |
3352 fprintf(stderr, "illegal short ref in memory management control operation %d\n", mmco); | |
3353 return -1; | |
3354 }*/ | |
3355 } | |
3356 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
3357 h->mmco[i].long_index= get_ue_golomb(&s->gb); | |
3358 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3359 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 3360 return -1; |
3361 } | |
3362 } | |
3363 | |
3364 if(opcode > MMCO_LONG){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3365 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 3366 return -1; |
3367 } | |
2255
507690ff49a2
assertion when playing AVC/H.264 streams fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2254
diff
changeset
|
3368 if(opcode == MMCO_END) |
507690ff49a2
assertion when playing AVC/H.264 streams fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2254
diff
changeset
|
3369 break; |
1168 | 3370 } |
3371 h->mmco_index= i; | |
3372 }else{ | |
3373 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
3374 | |
3375 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
3376 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
3377 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
3378 h->mmco_index= 1; | |
3379 }else | |
3380 h->mmco_index= 0; | |
3381 } | |
3382 } | |
3383 | |
3384 return 0; | |
3385 } | |
3386 | |
3387 static int init_poc(H264Context *h){ | |
3388 MpegEncContext * const s = &h->s; | |
3389 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
3390 int field_poc[2]; | |
3391 | |
3392 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
3393 h->frame_num_offset= 0; | |
3394 }else{ | |
3395 if(h->frame_num < h->prev_frame_num) | |
3396 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
3397 else | |
3398 h->frame_num_offset= h->prev_frame_num_offset; | |
3399 } | |
3400 | |
3401 if(h->sps.poc_type==0){ | |
3402 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
3403 | |
3404 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) | |
3405 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
3406 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
3407 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
3408 else | |
3409 h->poc_msb = h->prev_poc_msb; | |
3410 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
3411 field_poc[0] = | |
3412 field_poc[1] = h->poc_msb + h->poc_lsb; | |
3413 if(s->picture_structure == PICT_FRAME) | |
3414 field_poc[1] += h->delta_poc_bottom; | |
3415 }else if(h->sps.poc_type==1){ | |
3416 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
3417 int i; | |
3418 | |
3419 if(h->sps.poc_cycle_length != 0) | |
3420 abs_frame_num = h->frame_num_offset + h->frame_num; | |
3421 else | |
3422 abs_frame_num = 0; | |
3423 | |
3424 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
3425 abs_frame_num--; | |
3426 | |
3427 expected_delta_per_poc_cycle = 0; | |
3428 for(i=0; i < h->sps.poc_cycle_length; i++) | |
3429 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
3430 | |
3431 if(abs_frame_num > 0){ | |
3432 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
3433 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
3434 | |
3435 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
3436 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
3437 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
3438 } else | |
3439 expectedpoc = 0; | |
3440 | |
3441 if(h->nal_ref_idc == 0) | |
3442 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; | |
3443 | |
3444 field_poc[0] = expectedpoc + h->delta_poc[0]; | |
3445 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
3446 | |
3447 if(s->picture_structure == PICT_FRAME) | |
3448 field_poc[1] += h->delta_poc[1]; | |
3449 }else{ | |
3450 int poc; | |
3451 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
3452 poc= 0; | |
3453 }else{ | |
3454 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
3455 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
3456 } | |
3457 field_poc[0]= poc; | |
3458 field_poc[1]= poc; | |
3459 } | |
3460 | |
3461 if(s->picture_structure != PICT_BOTTOM_FIELD) | |
3462 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
3463 if(s->picture_structure != PICT_TOP_FIELD) | |
3464 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
3465 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
3466 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
3467 | |
3468 return 0; | |
3469 } | |
3470 | |
3471 /** | |
3472 * decodes a slice header. | |
3473 * this will allso call MPV_common_init() and frame_start() as needed | |
3474 */ | |
3475 static int decode_slice_header(H264Context *h){ | |
3476 MpegEncContext * const s = &h->s; | |
3477 int first_mb_in_slice, pps_id; | |
3478 int num_ref_idx_active_override_flag; | |
3479 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
3480 | |
3481 s->current_picture.reference= h->nal_ref_idc != 0; | |
3482 | |
3483 first_mb_in_slice= get_ue_golomb(&s->gb); | |
3484 | |
3485 h->slice_type= get_ue_golomb(&s->gb); | |
3486 if(h->slice_type > 9){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3487 av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y); |
2392 | 3488 return -1; |
1168 | 3489 } |
3490 if(h->slice_type > 4){ | |
3491 h->slice_type -= 5; | |
3492 h->slice_type_fixed=1; | |
3493 }else | |
3494 h->slice_type_fixed=0; | |
3495 | |
3496 h->slice_type= slice_type_map[ h->slice_type ]; | |
3497 | |
3498 s->pict_type= h->slice_type; // to make a few old func happy, its wrong though | |
3499 | |
3500 pps_id= get_ue_golomb(&s->gb); | |
3501 if(pps_id>255){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3502 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 3503 return -1; |
3504 } | |
3505 h->pps= h->pps_buffer[pps_id]; | |
1174 | 3506 if(h->pps.slice_group_count == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3507 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 3508 return -1; |
3509 } | |
3510 | |
1168 | 3511 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 3512 if(h->sps.log2_max_frame_num == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3513 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 3514 return -1; |
3515 } | |
1168 | 3516 |
3517 s->mb_width= h->sps.mb_width; | |
3518 s->mb_height= h->sps.mb_height; | |
3519 | |
2395 | 3520 h->b_stride= s->mb_width*4 + 1; |
3521 h->b8_stride= s->mb_width*2 + 1; | |
1168 | 3522 |
2392 | 3523 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3524 s->resync_mb_y = s->mb_y = first_mb_in_slice / s->mb_width; //FIXME AFFW | |
1168 | 3525 |
1371 | 3526 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 3527 if(h->sps.frame_mbs_only_flag) |
1371 | 3528 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 3529 else |
1371 | 3530 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
1168 | 3531 |
3532 if (s->context_initialized | |
1548 | 3533 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 3534 free_tables(h); |
3535 MPV_common_end(s); | |
3536 } | |
3537 if (!s->context_initialized) { | |
3538 if (MPV_common_init(s) < 0) | |
3539 return -1; | |
3540 | |
3541 alloc_tables(h); | |
3542 | |
3543 s->avctx->width = s->width; | |
3544 s->avctx->height = s->height; | |
1548 | 3545 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 3546 if(!s->avctx->sample_aspect_ratio.den) |
3547 s->avctx->sample_aspect_ratio.den = 1; | |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3548 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3549 if(h->sps.timing_info_present_flag && h->sps.fixed_frame_rate_flag){ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3550 s->avctx->frame_rate = h->sps.time_scale; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3551 s->avctx->frame_rate_base = h->sps.num_units_in_tick; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3552 } |
1168 | 3553 } |
3554 | |
2392 | 3555 if(h->slice_num == 0){ |
1168 | 3556 frame_start(h); |
3557 } | |
3558 | |
1169 | 3559 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 3560 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
3561 | |
3562 if(h->sps.frame_mbs_only_flag){ | |
3563 s->picture_structure= PICT_FRAME; | |
3564 }else{ | |
3565 if(get_bits1(&s->gb)) //field_pic_flag | |
3566 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag | |
3567 else | |
3568 s->picture_structure= PICT_FRAME; | |
3569 } | |
3570 | |
3571 if(s->picture_structure==PICT_FRAME){ | |
3572 h->curr_pic_num= h->frame_num; | |
3573 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
3574 }else{ | |
3575 h->curr_pic_num= 2*h->frame_num; | |
3576 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
3577 } | |
3578 | |
3579 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
1453 | 3580 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 3581 } |
3582 | |
3583 if(h->sps.poc_type==0){ | |
3584 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
3585 | |
3586 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ | |
3587 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
3588 } | |
3589 } | |
3590 | |
3591 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ | |
3592 h->delta_poc[0]= get_se_golomb(&s->gb); | |
3593 | |
3594 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) | |
3595 h->delta_poc[1]= get_se_golomb(&s->gb); | |
3596 } | |
3597 | |
3598 init_poc(h); | |
3599 | |
3600 if(h->pps.redundant_pic_cnt_present){ | |
3601 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
3602 } | |
3603 | |
3604 //set defaults, might be overriden a few line later | |
3605 h->ref_count[0]= h->pps.ref_count[0]; | |
3606 h->ref_count[1]= h->pps.ref_count[1]; | |
3607 | |
3608 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
3609 if(h->slice_type == B_TYPE){ | |
3610 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3611 } | |
3612 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
3613 | |
3614 if(num_ref_idx_active_override_flag){ | |
3615 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
3616 if(h->slice_type==B_TYPE) | |
3617 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
3618 | |
3619 if(h->ref_count[0] > 32 || h->ref_count[1] > 32){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3620 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
1168 | 3621 return -1; |
3622 } | |
3623 } | |
3624 } | |
3625 | |
2392 | 3626 if(h->slice_num == 0){ |
1168 | 3627 fill_default_ref_list(h); |
3628 } | |
3629 | |
3630 decode_ref_pic_list_reordering(h); | |
3631 | |
3632 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) | |
3633 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) | |
3634 pred_weight_table(h); | |
2415 | 3635 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
3636 implicit_weight_table(h); | |
3637 else | |
3638 h->use_weight = 0; | |
1168 | 3639 |
3640 if(s->current_picture.reference) | |
3641 decode_ref_pic_marking(h); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3642 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3643 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3644 h->cabac_init_idc = get_ue_golomb(&s->gb); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3645 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3646 h->last_qscale_diff = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3647 s->qscale = h->pps.init_qp + get_se_golomb(&s->gb); |
1898 | 3648 if(s->qscale<0 || s->qscale>51){ |
3649 av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale); | |
3650 return -1; | |
3651 } | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
3652 h->chroma_qp = get_chroma_qp(h, s->qscale); |
1168 | 3653 //FIXME qscale / qp ... stuff |
3654 if(h->slice_type == SP_TYPE){ | |
1453 | 3655 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 3656 } |
3657 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 3658 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 3659 } |
3660 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3661 h->deblocking_filter = 1; |
1898 | 3662 h->slice_alpha_c0_offset = 0; |
3663 h->slice_beta_offset = 0; | |
1168 | 3664 if( h->pps.deblocking_filter_parameters_present ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3665 h->deblocking_filter= get_ue_golomb(&s->gb); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3666 if(h->deblocking_filter < 2) |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3667 h->deblocking_filter^= 1; // 1<->0 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3668 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3669 if( h->deblocking_filter ) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3670 h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3671 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 3672 } |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3673 } |
1168 | 3674 |
3675 #if 0 //FMO | |
3676 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
3677 slice_group_change_cycle= get_bits(&s->gb, ?); | |
3678 #endif | |
3679 | |
2392 | 3680 h->slice_num++; |
3681 | |
1168 | 3682 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2415 | 3683 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d weight:%d%s\n", |
2392 | 3684 h->slice_num, first_mb_in_slice, |
1264 | 3685 av_get_pict_type_char(h->slice_type), |
1168 | 3686 pps_id, h->frame_num, |
3687 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
3688 h->ref_count[0], h->ref_count[1], | |
3689 s->qscale, | |
2415 | 3690 h->deblocking_filter, |
3691 h->use_weight, | |
3692 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 3693 ); |
3694 } | |
3695 | |
3696 return 0; | |
3697 } | |
3698 | |
3699 /** | |
3700 * | |
3701 */ | |
3702 static inline int get_level_prefix(GetBitContext *gb){ | |
3703 unsigned int buf; | |
3704 int log; | |
3705 | |
3706 OPEN_READER(re, gb); | |
3707 UPDATE_CACHE(re, gb); | |
3708 buf=GET_CACHE(re, gb); | |
3709 | |
3710 log= 32 - av_log2(buf); | |
3711 #ifdef TRACE | |
3712 print_bin(buf>>(32-log), log); | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
3713 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__); |
1168 | 3714 #endif |
3715 | |
3716 LAST_SKIP_BITS(re, gb, log); | |
3717 CLOSE_READER(re, gb); | |
3718 | |
3719 return log-1; | |
3720 } | |
3721 | |
3722 /** | |
3723 * decodes a residual block. | |
3724 * @param n block index | |
3725 * @param scantable scantable | |
3726 * @param max_coeff number of coefficients in the block | |
3727 * @return <0 if an error occured | |
3728 */ | |
3729 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, int qp, int max_coeff){ | |
3730 MpegEncContext * const s = &h->s; | |
3731 const uint16_t *qmul= dequant_coeff[qp]; | |
3732 static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}; | |
3733 int level[16], run[16]; | |
3734 int suffix_length, zeros_left, coeff_num, coeff_token, total_coeff, i, trailing_ones; | |
3735 | |
3736 //FIXME put trailing_onex into the context | |
3737 | |
3738 if(n == CHROMA_DC_BLOCK_INDEX){ | |
3739 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
3740 total_coeff= coeff_token>>2; | |
3741 }else{ | |
3742 if(n == LUMA_DC_BLOCK_INDEX){ | |
3743 total_coeff= pred_non_zero_count(h, 0); | |
3744 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
3745 total_coeff= coeff_token>>2; | |
3746 }else{ | |
3747 total_coeff= pred_non_zero_count(h, n); | |
3748 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
3749 total_coeff= coeff_token>>2; | |
3750 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
3751 } | |
3752 } | |
3753 | |
3754 //FIXME set last_non_zero? | |
3755 | |
3756 if(total_coeff==0) | |
3757 return 0; | |
3758 | |
3759 trailing_ones= coeff_token&3; | |
1170 | 3760 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 3761 assert(total_coeff<=16); |
3762 | |
3763 for(i=0; i<trailing_ones; i++){ | |
3764 level[i]= 1 - 2*get_bits1(gb); | |
3765 } | |
3766 | |
3767 suffix_length= total_coeff > 10 && trailing_ones < 3; | |
3768 | |
3769 for(; i<total_coeff; i++){ | |
3770 const int prefix= get_level_prefix(gb); | |
3771 int level_code, mask; | |
3772 | |
3773 if(prefix<14){ //FIXME try to build a large unified VLC table for all this | |
3774 if(suffix_length) | |
3775 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
3776 else | |
3777 level_code= (prefix<<suffix_length); //part | |
3778 }else if(prefix==14){ | |
3779 if(suffix_length) | |
3780 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
3781 else | |
3782 level_code= prefix + get_bits(gb, 4); //part | |
3783 }else if(prefix==15){ | |
3784 level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part | |
3785 if(suffix_length==0) level_code+=15; //FIXME doesnt make (much)sense | |
3786 }else{ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3787 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 3788 return -1; |
3789 } | |
3790 | |
3791 if(i==trailing_ones && i<3) level_code+= 2; //FIXME split first iteration | |
3792 | |
3793 mask= -(level_code&1); | |
3794 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
3795 | |
3796 if(suffix_length==0) suffix_length=1; //FIXME split first iteration | |
3797 | |
3798 #if 1 | |
3799 if(ABS(level[i]) > (3<<(suffix_length-1)) && suffix_length<6) suffix_length++; | |
3800 #else | |
3801 if((2+level_code)>>1) > (3<<(suffix_length-1)) && suffix_length<6) suffix_length++; | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3802 /* ? == prefix > 2 or sth */ |
1168 | 3803 #endif |
1170 | 3804 tprintf("level: %d suffix_length:%d\n", level[i], suffix_length); |
1168 | 3805 } |
3806 | |
3807 if(total_coeff == max_coeff) | |
3808 zeros_left=0; | |
3809 else{ | |
3810 if(n == CHROMA_DC_BLOCK_INDEX) | |
3811 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
3812 else | |
3813 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
3814 } | |
3815 | |
3816 for(i=0; i<total_coeff-1; i++){ | |
3817 if(zeros_left <=0) | |
3818 break; | |
3819 else if(zeros_left < 7){ | |
3820 run[i]= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
3821 }else{ | |
3822 run[i]= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
3823 } | |
3824 zeros_left -= run[i]; | |
3825 } | |
3826 | |
3827 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3828 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 3829 return -1; |
3830 } | |
3831 | |
3832 for(; i<total_coeff-1; i++){ | |
3833 run[i]= 0; | |
3834 } | |
3835 | |
3836 run[i]= zeros_left; | |
3837 | |
3838 coeff_num=-1; | |
3839 if(n > 24){ | |
3840 for(i=total_coeff-1; i>=0; i--){ //FIXME merge into rundecode? | |
3841 int j; | |
3842 | |
3843 coeff_num += run[i] + 1; //FIXME add 1 earlier ? | |
3844 j= scantable[ coeff_num ]; | |
3845 | |
3846 block[j]= level[i]; | |
3847 } | |
3848 }else{ | |
3849 for(i=total_coeff-1; i>=0; i--){ //FIXME merge into rundecode? | |
3850 int j; | |
3851 | |
3852 coeff_num += run[i] + 1; //FIXME add 1 earlier ? | |
3853 j= scantable[ coeff_num ]; | |
3854 | |
3855 block[j]= level[i] * qmul[j]; | |
3856 // printf("%d %d ", block[j], qmul[j]); | |
3857 } | |
3858 } | |
3859 return 0; | |
3860 } | |
3861 | |
3862 /** | |
2396 | 3863 * decodes a P_SKIP or B_SKIP macroblock |
3864 */ | |
3865 static void decode_mb_skip(H264Context *h){ | |
3866 MpegEncContext * const s = &h->s; | |
3867 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
3868 int mb_type; | |
3869 | |
3870 memset(h->non_zero_count[mb_xy], 0, 16); | |
3871 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
3872 | |
3873 if( h->slice_type == B_TYPE ) | |
3874 { | |
3875 // just for fill_caches. pred_direct_motion will set the real mb_type | |
3876 mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; | |
3877 //FIXME mbaff | |
3878 | |
2449 | 3879 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 3880 pred_direct_motion(h, &mb_type); |
3881 if(h->pps.cabac){ | |
3882 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
3883 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
3884 } | |
3885 } | |
3886 else | |
3887 { | |
3888 int mx, my; | |
3889 mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; | |
3890 | |
3891 if(h->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){ | |
3892 h->mb_field_decoding_flag= get_bits1(&s->gb); | |
3893 } | |
3894 if(h->mb_field_decoding_flag) | |
3895 mb_type|= MB_TYPE_INTERLACED; | |
3896 | |
2449 | 3897 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 3898 pred_pskip_motion(h, &mx, &my); |
3899 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
3900 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
3901 if(h->pps.cabac) | |
3902 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
3903 } | |
3904 | |
3905 write_back_motion(h, mb_type); | |
3906 s->current_picture.mb_type[mb_xy]= mb_type|MB_TYPE_SKIP; | |
3907 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
3908 h->slice_table[ mb_xy ]= h->slice_num; | |
3909 h->prev_mb_skiped= 1; | |
3910 } | |
3911 | |
3912 /** | |
1168 | 3913 * decodes a macroblock |
3914 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
3915 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3916 static int decode_mb_cavlc(H264Context *h){ |
1168 | 3917 MpegEncContext * const s = &h->s; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
3918 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1169 | 3919 int mb_type, partition_count, cbp; |
1168 | 3920 |
1252 | 3921 s->dsp.clear_blocks(h->mb); //FIXME avoid if allready clear (move after skip handlong? |
1168 | 3922 |
1170 | 3923 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 3924 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
3925 down the code */ | |
1168 | 3926 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
3927 if(s->mb_skip_run==-1) | |
3928 s->mb_skip_run= get_ue_golomb(&s->gb); | |
3929 | |
3930 if (s->mb_skip_run--) { | |
2396 | 3931 decode_mb_skip(h); |
1168 | 3932 return 0; |
3933 } | |
3934 } | |
3935 if(h->sps.mb_aff /* && !field pic FIXME needed? */){ | |
3936 if((s->mb_y&1)==0) | |
3937 h->mb_field_decoding_flag = get_bits1(&s->gb); | |
3938 }else | |
3939 h->mb_field_decoding_flag=0; //FIXME som ed note ?! | |
3940 | |
3941 h->prev_mb_skiped= 0; | |
3942 | |
3943 mb_type= get_ue_golomb(&s->gb); | |
3944 if(h->slice_type == B_TYPE){ | |
3945 if(mb_type < 23){ | |
3946 partition_count= b_mb_type_info[mb_type].partition_count; | |
3947 mb_type= b_mb_type_info[mb_type].type; | |
3948 }else{ | |
3949 mb_type -= 23; | |
3950 goto decode_intra_mb; | |
3951 } | |
3952 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
3953 if(mb_type < 5){ | |
3954 partition_count= p_mb_type_info[mb_type].partition_count; | |
3955 mb_type= p_mb_type_info[mb_type].type; | |
3956 }else{ | |
3957 mb_type -= 5; | |
3958 goto decode_intra_mb; | |
3959 } | |
3960 }else{ | |
3961 assert(h->slice_type == I_TYPE); | |
3962 decode_intra_mb: | |
3963 if(mb_type > 25){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3964 av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y); |
1168 | 3965 return -1; |
3966 } | |
3967 partition_count=0; | |
3968 cbp= i_mb_type_info[mb_type].cbp; | |
3969 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
3970 mb_type= i_mb_type_info[mb_type].type; | |
3971 } | |
3972 | |
3973 if(h->mb_field_decoding_flag) | |
3974 mb_type |= MB_TYPE_INTERLACED; | |
3975 | |
3976 s->current_picture.mb_type[mb_xy]= mb_type; | |
3977 h->slice_table[ mb_xy ]= h->slice_num; | |
3978 | |
3979 if(IS_INTRA_PCM(mb_type)){ | |
3980 const uint8_t *ptr; | |
1187 | 3981 int x, y; |
1168 | 3982 |
3983 // we assume these blocks are very rare so we dont optimize it | |
3984 align_get_bits(&s->gb); | |
3985 | |
3986 ptr= s->gb.buffer + get_bits_count(&s->gb); | |
3987 | |
3988 for(y=0; y<16; y++){ | |
3989 const int index= 4*(y&3) + 64*(y>>2); | |
3990 for(x=0; x<16; x++){ | |
3991 h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++); | |
3992 } | |
3993 } | |
3994 for(y=0; y<8; y++){ | |
3995 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
3996 for(x=0; x<8; x++){ | |
3997 h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++); | |
3998 } | |
3999 } | |
4000 for(y=0; y<8; y++){ | |
4001 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
4002 for(x=0; x<8; x++){ | |
4003 h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++); | |
4004 } | |
4005 } | |
4006 | |
4007 skip_bits(&s->gb, 384); //FIXME check /fix the bitstream readers | |
4008 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4009 //FIXME deblock filter, non_zero_count_cache init ... |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4010 memset(h->non_zero_count[mb_xy], 16, 16); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
4011 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 4012 |
4013 return 0; | |
4014 } | |
4015 | |
2449 | 4016 fill_caches(h, mb_type, 0); |
1168 | 4017 |
4018 //mb_pred | |
4019 if(IS_INTRA(mb_type)){ | |
4020 // init_top_left_availability(h); | |
4021 if(IS_INTRA4x4(mb_type)){ | |
4022 int i; | |
4023 | |
4024 // fill_intra4x4_pred_table(h); | |
4025 for(i=0; i<16; i++){ | |
4026 const int mode_coded= !get_bits1(&s->gb); | |
4027 const int predicted_mode= pred_intra_mode(h, i); | |
4028 int mode; | |
4029 | |
4030 if(mode_coded){ | |
4031 const int rem_mode= get_bits(&s->gb, 3); | |
4032 if(rem_mode<predicted_mode) | |
4033 mode= rem_mode; | |
4034 else | |
4035 mode= rem_mode + 1; | |
4036 }else{ | |
4037 mode= predicted_mode; | |
4038 } | |
4039 | |
4040 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
4041 } | |
4042 write_back_intra_pred_mode(h); | |
4043 if( check_intra4x4_pred_mode(h) < 0) | |
4044 return -1; | |
4045 }else{ | |
4046 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
4047 if(h->intra16x16_pred_mode < 0) | |
4048 return -1; | |
4049 } | |
4050 h->chroma_pred_mode= get_ue_golomb(&s->gb); | |
4051 | |
4052 h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode); | |
4053 if(h->chroma_pred_mode < 0) | |
4054 return -1; | |
4055 }else if(partition_count==4){ | |
4056 int i, j, sub_partition_count[4], list, ref[2][4]; | |
4057 | |
4058 if(h->slice_type == B_TYPE){ | |
4059 for(i=0; i<4; i++){ | |
4060 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4061 if(h->sub_mb_type[i] >=13){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4062 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 4063 return -1; |
4064 } | |
4065 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4066 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4067 } | |
2396 | 4068 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
4069 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) | |
4070 pred_direct_motion(h, &mb_type); | |
1168 | 4071 }else{ |
4072 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
4073 for(i=0; i<4; i++){ | |
4074 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4075 if(h->sub_mb_type[i] >=4){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4076 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 4077 return -1; |
4078 } | |
4079 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4080 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4081 } | |
4082 } | |
4083 | |
4084 for(list=0; list<2; list++){ | |
4085 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
4086 if(ref_count == 0) continue; | |
4087 for(i=0; i<4; i++){ | |
2396 | 4088 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
4089 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1168 | 4090 ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
4091 }else{ | |
4092 //FIXME | |
4093 ref[list][i] = -1; | |
4094 } | |
4095 } | |
4096 } | |
4097 | |
4098 for(list=0; list<2; list++){ | |
4099 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
4100 if(ref_count == 0) continue; | |
4101 | |
4102 for(i=0; i<4; i++){ | |
2396 | 4103 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
1168 | 4104 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
4105 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
4106 | |
2396 | 4107 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 4108 const int sub_mb_type= h->sub_mb_type[i]; |
4109 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
4110 for(j=0; j<sub_partition_count[i]; j++){ | |
4111 int mx, my; | |
4112 const int index= 4*i + block_width*j; | |
4113 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
4114 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
4115 mx += get_se_golomb(&s->gb); | |
4116 my += get_se_golomb(&s->gb); | |
1170 | 4117 tprintf("final mv:%d %d\n", mx, my); |
4118 | |
1168 | 4119 if(IS_SUB_8X8(sub_mb_type)){ |
4120 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= | |
4121 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
4122 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= | |
4123 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
4124 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4125 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; | |
4126 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; | |
4127 }else if(IS_SUB_4X8(sub_mb_type)){ | |
4128 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; | |
4129 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; | |
4130 }else{ | |
4131 assert(IS_SUB_4X4(sub_mb_type)); | |
4132 mv_cache[ 0 ][0]= mx; | |
4133 mv_cache[ 0 ][1]= my; | |
4134 } | |
4135 } | |
4136 }else{ | |
4137 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
4138 p[0] = p[1]= | |
4139 p[8] = p[9]= 0; | |
4140 } | |
4141 } | |
4142 } | |
2396 | 4143 }else if(IS_DIRECT(mb_type)){ |
4144 pred_direct_motion(h, &mb_type); | |
4145 s->current_picture.mb_type[mb_xy]= mb_type; | |
4146 }else{ | |
1168 | 4147 int list, mx, my, i; |
4148 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
4149 if(IS_16X16(mb_type)){ | |
4150 for(list=0; list<2; list++){ | |
2392 | 4151 if(h->ref_count[list]>0){ |
1168 | 4152 if(IS_DIR(mb_type, 0, list)){ |
4153 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
4154 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
4155 } | |
4156 } | |
4157 } | |
4158 for(list=0; list<2; list++){ | |
4159 if(IS_DIR(mb_type, 0, list)){ | |
4160 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
4161 mx += get_se_golomb(&s->gb); | |
4162 my += get_se_golomb(&s->gb); | |
1170 | 4163 tprintf("final mv:%d %d\n", mx, my); |
4164 | |
1269 | 4165 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
1168 | 4166 } |
4167 } | |
4168 } | |
4169 else if(IS_16X8(mb_type)){ | |
4170 for(list=0; list<2; list++){ | |
4171 if(h->ref_count[list]>0){ | |
4172 for(i=0; i<2; i++){ | |
4173 if(IS_DIR(mb_type, i, list)){ | |
4174 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
4175 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
2396 | 4176 }else // needed only for mixed refs (e.g. B_L0_L1_16x8) |
4177 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 4178 } |
4179 } | |
4180 } | |
4181 for(list=0; list<2; list++){ | |
4182 for(i=0; i<2; i++){ | |
4183 if(IS_DIR(mb_type, i, list)){ | |
4184 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
4185 mx += get_se_golomb(&s->gb); | |
4186 my += get_se_golomb(&s->gb); | |
1170 | 4187 tprintf("final mv:%d %d\n", mx, my); |
4188 | |
1269 | 4189 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 4190 }else |
4191 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 4192 } |
4193 } | |
4194 }else{ | |
4195 assert(IS_8X16(mb_type)); | |
4196 for(list=0; list<2; list++){ | |
4197 if(h->ref_count[list]>0){ | |
4198 for(i=0; i<2; i++){ | |
4199 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
4200 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
4201 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
2396 | 4202 }else // needed only for mixed refs |
4203 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 4204 } |
4205 } | |
4206 } | |
4207 for(list=0; list<2; list++){ | |
4208 for(i=0; i<2; i++){ | |
4209 if(IS_DIR(mb_type, i, list)){ | |
4210 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
4211 mx += get_se_golomb(&s->gb); | |
4212 my += get_se_golomb(&s->gb); | |
1170 | 4213 tprintf("final mv:%d %d\n", mx, my); |
4214 | |
1269 | 4215 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 4216 }else |
4217 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 4218 } |
4219 } | |
4220 } | |
4221 } | |
4222 | |
4223 if(IS_INTER(mb_type)) | |
4224 write_back_motion(h, mb_type); | |
4225 | |
4226 if(!IS_INTRA16x16(mb_type)){ | |
4227 cbp= get_ue_golomb(&s->gb); | |
4228 if(cbp > 47){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4229 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 4230 return -1; |
4231 } | |
4232 | |
4233 if(IS_INTRA4x4(mb_type)) | |
4234 cbp= golomb_to_intra4x4_cbp[cbp]; | |
4235 else | |
4236 cbp= golomb_to_inter_cbp[cbp]; | |
4237 } | |
4238 | |
4239 if(cbp || IS_INTRA16x16(mb_type)){ | |
4240 int i8x8, i4x4, chroma_idx; | |
4241 int chroma_qp, dquant; | |
4242 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
4243 const uint8_t *scan, *dc_scan; | |
4244 | |
4245 // fill_non_zero_count_cache(h); | |
4246 | |
4247 if(IS_INTERLACED(mb_type)){ | |
4248 scan= field_scan; | |
4249 dc_scan= luma_dc_field_scan; | |
4250 }else{ | |
4251 scan= zigzag_scan; | |
4252 dc_scan= luma_dc_zigzag_scan; | |
4253 } | |
4254 | |
4255 dquant= get_se_golomb(&s->gb); | |
4256 | |
4257 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4258 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y); |
1168 | 4259 return -1; |
4260 } | |
4261 | |
4262 s->qscale += dquant; | |
4263 if(((unsigned)s->qscale) > 51){ | |
4264 if(s->qscale<0) s->qscale+= 52; | |
4265 else s->qscale-= 52; | |
4266 } | |
4267 | |
4268 h->chroma_qp= chroma_qp= get_chroma_qp(h, s->qscale); | |
4269 if(IS_INTRA16x16(mb_type)){ | |
4270 if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, s->qscale, 16) < 0){ | |
4271 return -1; //FIXME continue if partotioned and other retirn -1 too | |
4272 } | |
4273 | |
4274 assert((cbp&15) == 0 || (cbp&15) == 15); | |
4275 | |
4276 if(cbp&15){ | |
4277 for(i8x8=0; i8x8<4; i8x8++){ | |
4278 for(i4x4=0; i4x4<4; i4x4++){ | |
4279 const int index= i4x4 + 4*i8x8; | |
4280 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, s->qscale, 15) < 0 ){ | |
4281 return -1; | |
4282 } | |
4283 } | |
4284 } | |
4285 }else{ | |
1636 | 4286 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 4287 } |
4288 }else{ | |
4289 for(i8x8=0; i8x8<4; i8x8++){ | |
4290 if(cbp & (1<<i8x8)){ | |
4291 for(i4x4=0; i4x4<4; i4x4++){ | |
4292 const int index= i4x4 + 4*i8x8; | |
4293 | |
4294 if( decode_residual(h, gb, h->mb + 16*index, index, scan, s->qscale, 16) <0 ){ | |
4295 return -1; | |
4296 } | |
4297 } | |
4298 }else{ | |
4299 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
4300 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
4301 } | |
4302 } | |
4303 } | |
4304 | |
4305 if(cbp&0x30){ | |
4306 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
4307 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, chroma_qp, 4) < 0){ | |
4308 return -1; | |
4309 } | |
4310 } | |
4311 | |
4312 if(cbp&0x20){ | |
4313 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
4314 for(i4x4=0; i4x4<4; i4x4++){ | |
4315 const int index= 16 + 4*chroma_idx + i4x4; | |
4316 if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, chroma_qp, 15) < 0){ | |
4317 return -1; | |
4318 } | |
4319 } | |
4320 } | |
4321 }else{ | |
4322 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
4323 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
4324 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
4325 } | |
4326 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4327 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4328 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4329 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4330 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 4331 } |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
4332 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 4333 write_back_non_zero_count(h); |
4334 | |
4335 return 0; | |
4336 } | |
4337 | |
2312 | 4338 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
4339 uint8_t *state= &h->cabac_state[ctx_base]; | |
4340 int mb_type; | |
4341 | |
4342 if(intra_slice){ | |
4343 MpegEncContext * const s = &h->s; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4344 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
2312 | 4345 int ctx=0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4346 if( s->mb_x > 0 && !IS_INTRA4x4( s->current_picture.mb_type[mb_xy-1] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4347 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4348 if( s->mb_y > 0 && !IS_INTRA4x4( s->current_picture.mb_type[mb_xy-s->mb_stride] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4349 ctx++; |
2312 | 4350 if( get_cabac( &h->cabac, &state[ctx] ) == 0 ) |
4351 return 0; /* I4x4 */ | |
4352 state += 2; | |
4353 }else{ | |
4354 if( get_cabac( &h->cabac, &state[0] ) == 0 ) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4355 return 0; /* I4x4 */ |
2312 | 4356 } |
4357 | |
4358 if( get_cabac_terminate( &h->cabac ) ) | |
4359 return 25; /* PCM */ | |
4360 | |
4361 mb_type = 1; /* I16x16 */ | |
4362 if( get_cabac( &h->cabac, &state[1] ) ) | |
4363 mb_type += 12; /* cbp_luma != 0 */ | |
4364 | |
4365 if( get_cabac( &h->cabac, &state[2] ) ) { | |
4366 if( get_cabac( &h->cabac, &state[2+intra_slice] ) ) | |
4367 mb_type += 4 * 2; /* cbp_chroma == 2 */ | |
4368 else | |
4369 mb_type += 4 * 1; /* cbp_chroma == 1 */ | |
4370 } | |
4371 if( get_cabac( &h->cabac, &state[3+intra_slice] ) ) | |
4372 mb_type += 2; | |
4373 if( get_cabac( &h->cabac, &state[3+2*intra_slice] ) ) | |
4374 mb_type += 1; | |
4375 return mb_type; | |
4376 } | |
4377 | |
4378 static int decode_cabac_mb_type( H264Context *h ) { | |
4379 MpegEncContext * const s = &h->s; | |
4380 | |
4381 if( h->slice_type == I_TYPE ) { | |
4382 return decode_cabac_intra_mb_type(h, 3, 1); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4383 } else if( h->slice_type == P_TYPE ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4384 if( get_cabac( &h->cabac, &h->cabac_state[14] ) == 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4385 /* P-type */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4386 if( get_cabac( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4387 if( get_cabac( &h->cabac, &h->cabac_state[16] ) == 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4388 return 0; /* P_L0_D16x16; */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4389 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4390 return 3; /* P_8x8; */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4391 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4392 if( get_cabac( &h->cabac, &h->cabac_state[17] ) == 0 ) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4393 return 2; /* P_L0_D8x16; */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4394 else |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4395 return 1; /* P_L0_D16x8; */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4396 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4397 } else { |
2312 | 4398 return decode_cabac_intra_mb_type(h, 17, 0) + 5; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4399 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4400 } else if( h->slice_type == B_TYPE ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4401 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4402 int ctx = 0; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4403 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4404 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4405 if( s->mb_x > 0 && !IS_SKIP( s->current_picture.mb_type[mb_xy-1] ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4406 && !IS_DIRECT( s->current_picture.mb_type[mb_xy-1] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4407 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4408 if( s->mb_y > 0 && !IS_SKIP( s->current_picture.mb_type[mb_xy-s->mb_stride] ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4409 && !IS_DIRECT( s->current_picture.mb_type[mb_xy-s->mb_stride] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4410 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4411 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4412 if( !get_cabac( &h->cabac, &h->cabac_state[27+ctx] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4413 return 0; /* B_Direct_16x16 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4414 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4415 if( !get_cabac( &h->cabac, &h->cabac_state[27+3] ) ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4416 return 1 + get_cabac( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4417 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4418 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4419 bits = get_cabac( &h->cabac, &h->cabac_state[27+4] ) << 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4420 bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 2; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4421 bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 1; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4422 bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4423 if( bits < 8 ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4424 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4425 else if( bits == 13 ) { |
2312 | 4426 return decode_cabac_intra_mb_type(h, 32, 0) + 23; |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4427 } else if( bits == 14 ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4428 return 11; /* B_L1_L0_8x16 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4429 else if( bits == 15 ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4430 return 22; /* B_8x8 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4431 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4432 bits= ( bits<<1 ) | get_cabac( &h->cabac, &h->cabac_state[27+5] ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4433 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4434 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4435 /* TODO SI/SP frames? */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4436 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4437 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4438 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4439 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4440 static int decode_cabac_mb_skip( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4441 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4442 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4443 const int mba_xy = mb_xy - 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4444 const int mbb_xy = mb_xy - s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4445 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4446 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4447 if( s->mb_x > 0 && !IS_SKIP( s->current_picture.mb_type[mba_xy] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4448 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4449 if( s->mb_y > 0 && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4450 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4451 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4452 if( h->slice_type == P_TYPE || h->slice_type == SP_TYPE) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4453 return get_cabac( &h->cabac, &h->cabac_state[11+ctx] ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4454 else /* B-frame */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4455 return get_cabac( &h->cabac, &h->cabac_state[24+ctx] ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4456 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4457 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4458 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4459 int mode = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4460 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4461 if( get_cabac( &h->cabac, &h->cabac_state[68] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4462 return pred_mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4463 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4464 if( get_cabac( &h->cabac, &h->cabac_state[69] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4465 mode += 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4466 if( get_cabac( &h->cabac, &h->cabac_state[69] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4467 mode += 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4468 if( get_cabac( &h->cabac, &h->cabac_state[69] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4469 mode += 4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4470 if( mode >= pred_mode ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4471 return mode + 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4472 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4473 return mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4474 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4475 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4476 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4477 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4478 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4479 const int mba_xy = mb_xy - 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4480 const int mbb_xy = mb_xy - s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4481 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4482 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4483 |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4484 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ |
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4485 if( s->mb_x > 0 && h->chroma_pred_mode_table[mba_xy] != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4486 ctx++; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4487 |
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4488 if( s->mb_y > 0 && h->chroma_pred_mode_table[mbb_xy] != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4489 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4490 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4491 if( get_cabac( &h->cabac, &h->cabac_state[64+ctx] ) == 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4492 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4493 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4494 if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4495 return 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4496 if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4497 return 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4498 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4499 return 3; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4500 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4501 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4502 static const uint8_t block_idx_x[16] = { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4503 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4504 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4505 static const uint8_t block_idx_y[16] = { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4506 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4507 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4508 static const uint8_t block_idx_xy[4][4] = { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4509 { 0, 2, 8, 10}, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4510 { 1, 3, 9, 11}, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4511 { 4, 6, 12, 14}, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4512 { 5, 7, 13, 15} |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4513 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4514 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4515 static int decode_cabac_mb_cbp_luma( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4516 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4517 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4518 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4519 int cbp = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4520 int i8x8; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4521 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4522 h->cbp_table[mb_xy] = 0; /* FIXME aaahahahah beurk */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4523 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4524 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4525 int mba_xy = -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4526 int mbb_xy = -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4527 int x, y; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4528 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4529 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4530 x = block_idx_x[4*i8x8]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4531 y = block_idx_y[4*i8x8]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4532 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4533 if( x > 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4534 mba_xy = mb_xy; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4535 else if( s->mb_x > 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4536 mba_xy = mb_xy - 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4537 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4538 if( y > 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4539 mbb_xy = mb_xy; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4540 else if( s->mb_y > 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4541 mbb_xy = mb_xy - s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4542 |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4543 /* No need to test for skip as we put 0 for skip block */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4544 if( mba_xy >= 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4545 int i8x8a = block_idx_xy[(x-1)&0x03][y]/4; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4546 if( ((h->cbp_table[mba_xy] >> i8x8a)&0x01) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4547 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4548 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4549 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4550 if( mbb_xy >= 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4551 int i8x8b = block_idx_xy[x][(y-1)&0x03]/4; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4552 if( ((h->cbp_table[mbb_xy] >> i8x8b)&0x01) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4553 ctx += 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4554 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4555 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4556 if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4557 cbp |= 1 << i8x8; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4558 h->cbp_table[mb_xy] = cbp; /* FIXME aaahahahah beurk */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4559 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4560 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4561 return cbp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4562 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4563 static int decode_cabac_mb_cbp_chroma( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4564 int ctx; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4565 int cbp_a, cbp_b; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4566 |
2314 | 4567 cbp_a = (h->left_cbp>>4)&0x03; |
4568 cbp_b = (h-> top_cbp>>4)&0x03; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4569 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4570 ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4571 if( cbp_a > 0 ) ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4572 if( cbp_b > 0 ) ctx += 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4573 if( get_cabac( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4574 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4575 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4576 ctx = 4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4577 if( cbp_a == 2 ) ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4578 if( cbp_b == 2 ) ctx += 2; |
2314 | 4579 return 1 + get_cabac( &h->cabac, &h->cabac_state[77 + ctx] ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4580 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4581 static int decode_cabac_mb_dqp( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4582 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4583 int mbn_xy; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4584 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4585 int val = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4586 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4587 if( s->mb_x > 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4588 mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4589 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4590 mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4591 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4592 if( mbn_xy >= 0 && h->last_qscale_diff != 0 && ( IS_INTRA16x16(s->current_picture.mb_type[mbn_xy] ) || (h->cbp_table[mbn_xy]&0x3f) ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4593 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4594 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4595 while( get_cabac( &h->cabac, &h->cabac_state[60 + ctx] ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4596 if( ctx < 2 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4597 ctx = 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4598 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4599 ctx = 3; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4600 val++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4601 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4602 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4603 if( val&0x01 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4604 return (val + 1)/2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4605 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4606 return -(val + 1)/2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4607 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4608 static int decode_cabac_p_mb_sub_type( H264Context *h ) { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4609 if( get_cabac( &h->cabac, &h->cabac_state[21] ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4610 return 0; /* 8x8 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4611 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4612 return 1; /* 8x4 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4613 if( get_cabac( &h->cabac, &h->cabac_state[23] ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4614 return 2; /* 4x8 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4615 return 3; /* 4x4 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4616 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4617 static int decode_cabac_b_mb_sub_type( H264Context *h ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4618 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4619 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4620 return 0; /* B_Direct_8x8 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4621 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) ) |
2311
cdbb2f30e08b
small typo patch by (Gildas Bazin <gbazin at altern dot org>)
michael
parents:
2310
diff
changeset
|
4622 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */ |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4623 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4624 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4625 if( get_cabac( &h->cabac, &h->cabac_state[39] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4626 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4627 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4628 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4629 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4630 type += get_cabac( &h->cabac, &h->cabac_state[39] ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4631 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4632 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4633 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4634 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4635 int refa = h->ref_cache[list][scan8[n] - 1]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4636 int refb = h->ref_cache[list][scan8[n] - 8]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4637 int ref = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4638 int ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4639 |
2396 | 4640 if( h->slice_type == B_TYPE) { |
4641 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
4642 ctx++; | |
4643 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
4644 ctx += 2; | |
4645 } else { | |
4646 if( refa > 0 ) | |
4647 ctx++; | |
4648 if( refb > 0 ) | |
4649 ctx += 2; | |
4650 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4651 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4652 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4653 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4654 if( ctx < 4 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4655 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4656 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4657 ctx = 5; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4658 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4659 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4660 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4661 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4662 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4663 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) + |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4664 abs( h->mvd_cache[list][scan8[n] - 8][l] ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4665 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 4666 int ctx, mvd; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4667 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4668 if( amvd < 3 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4669 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4670 else if( amvd > 32 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4671 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4672 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4673 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4674 |
2317 | 4675 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
4676 return 0; | |
4677 | |
4678 mvd= 1; | |
4679 ctx= 3; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4680 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4681 mvd++; |
2317 | 4682 if( ctx < 6 ) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4683 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4684 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4685 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4686 if( mvd >= 9 ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4687 int k = 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4688 while( get_cabac_bypass( &h->cabac ) ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4689 mvd += 1 << k; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4690 k++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4691 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4692 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4693 if( get_cabac_bypass( &h->cabac ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4694 mvd += 1 << k; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4695 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4696 } |
2317 | 4697 if( get_cabac_bypass( &h->cabac ) ) return -mvd; |
4698 else return mvd; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4699 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4700 |
2316 | 4701 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 4702 int nza, nzb; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4703 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4704 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4705 if( cat == 0 ) { |
2314 | 4706 nza = h->left_cbp&0x100; |
4707 nzb = h-> top_cbp&0x100; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4708 } else if( cat == 1 || cat == 2 ) { |
2314 | 4709 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
4710 nzb = h->non_zero_count_cache[scan8[idx] - 8]; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4711 } else if( cat == 3 ) { |
2314 | 4712 nza = (h->left_cbp>>(6+idx))&0x01; |
4713 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
4714 } else { | |
4715 assert(cat == 4); | |
4716 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
4717 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
4718 } | |
4719 | |
4720 if( nza > 0 ) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4721 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4722 |
2314 | 4723 if( nzb > 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4724 ctx += 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4725 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4726 return ctx + 4 * cat; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4727 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4728 |
2316 | 4729 static int inline decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int qp, int max_coeff) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4730 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4731 const uint16_t *qmul= dequant_coeff[qp]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4732 static const int significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 }; |
2313 | 4733 static const int coeff_abs_level_m1_offset[5] = {227+ 0, 227+10, 227+20, 227+30, 227+39 }; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4734 |
2313 | 4735 int index[16]; |
4736 | |
4737 int i, last; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4738 int coeff_count = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4739 |
2316 | 4740 int abslevel1 = 1; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4741 int abslevelgt1 = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4742 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4743 /* cat: 0-> DC 16x16 n = 0 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4744 * 1-> AC 16x16 n = luma4x4idx |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4745 * 2-> Luma4x4 n = luma4x4idx |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4746 * 3-> DC Chroma n = iCbCr |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4747 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4748 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4749 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4750 /* read coded block flag */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4751 if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4752 if( cat == 1 || cat == 2 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4753 h->non_zero_count_cache[scan8[n]] = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4754 else if( cat == 4 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4755 h->non_zero_count_cache[scan8[16+n]] = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4756 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4757 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4758 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4759 |
2313 | 4760 for(last= 0; last < max_coeff - 1; last++) { |
4761 if( get_cabac( &h->cabac, &h->cabac_state[105+significant_coeff_flag_offset[cat]+last] )) { | |
4762 index[coeff_count++] = last; | |
4763 if( get_cabac( &h->cabac, &h->cabac_state[166+significant_coeff_flag_offset[cat]+last] ) ) { | |
4764 last= max_coeff; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4765 break; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4766 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4767 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4768 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4769 if( last == max_coeff -1 ) { |
2313 | 4770 index[coeff_count++] = last; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4771 } |
2316 | 4772 assert(coeff_count > 0); |
4773 | |
4774 if( cat == 0 ) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4775 h->cbp_table[mb_xy] |= 0x100; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4776 else if( cat == 1 || cat == 2 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4777 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 4778 else if( cat == 3 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4779 h->cbp_table[mb_xy] |= 0x40 << n; |
2316 | 4780 else { |
4781 assert( cat == 4 ); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4782 h->non_zero_count_cache[scan8[16+n]] = coeff_count; |
2316 | 4783 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4784 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4785 for( i = coeff_count - 1; i >= 0; i-- ) { |
2316 | 4786 int ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + coeff_abs_level_m1_offset[cat]; |
4787 int j= scantable[index[i]]; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4788 |
2313 | 4789 if( get_cabac( &h->cabac, &h->cabac_state[ctx] ) == 0 ) { |
2316 | 4790 if( cat == 0 || cat == 3 ) { |
4791 if( get_cabac_bypass( &h->cabac ) ) block[j] = -1; | |
4792 else block[j] = 1; | |
4793 }else{ | |
4794 if( get_cabac_bypass( &h->cabac ) ) block[j] = -qmul[j]; | |
4795 else block[j] = qmul[j]; | |
4796 } | |
2313 | 4797 |
4798 abslevel1++; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4799 } else { |
2313 | 4800 int coeff_abs = 2; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4801 ctx = 5 + FFMIN( 4, abslevelgt1 ) + coeff_abs_level_m1_offset[cat]; |
2313 | 4802 while( coeff_abs < 15 && get_cabac( &h->cabac, &h->cabac_state[ctx] ) ) { |
4803 coeff_abs++; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4804 } |
2313 | 4805 |
4806 if( coeff_abs >= 15 ) { | |
4807 int j = 0; | |
4808 while( get_cabac_bypass( &h->cabac ) ) { | |
4809 coeff_abs += 1 << j; | |
4810 j++; | |
4811 } | |
4812 | |
4813 while( j-- ) { | |
4814 if( get_cabac_bypass( &h->cabac ) ) | |
4815 coeff_abs += 1 << j ; | |
4816 } | |
4817 } | |
4818 | |
2316 | 4819 if( cat == 0 || cat == 3 ) { |
4820 if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs; | |
4821 else block[j] = coeff_abs; | |
4822 }else{ | |
4823 if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs * qmul[j]; | |
4824 else block[j] = coeff_abs * qmul[j]; | |
4825 } | |
2313 | 4826 |
4827 abslevelgt1++; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4828 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4829 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4830 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4831 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4832 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4833 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4834 * decodes a macroblock |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4835 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4836 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4837 static int decode_mb_cabac(H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4838 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4839 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4840 int mb_type, partition_count, cbp = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4841 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4842 s->dsp.clear_blocks(h->mb); //FIXME avoid if allready clear (move after skip handlong?) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4843 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4844 if( h->sps.mb_aff ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4845 av_log( h->s.avctx, AV_LOG_ERROR, "Fields not supported with CABAC\n" ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4846 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4847 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4848 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4849 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4850 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4851 /* read skip flags */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4852 if( decode_cabac_mb_skip( h ) ) { |
2396 | 4853 decode_mb_skip(h); |
4854 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4855 h->cbp_table[mb_xy] = 0; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4856 h->chroma_pred_mode_table[mb_xy] = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4857 h->last_qscale_diff = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4858 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4859 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4860 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4861 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4862 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4863 h->prev_mb_skiped = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4864 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4865 if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4866 av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4867 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4868 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4869 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4870 if( h->slice_type == B_TYPE ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4871 if( mb_type < 23 ){ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4872 partition_count= b_mb_type_info[mb_type].partition_count; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4873 mb_type= b_mb_type_info[mb_type].type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4874 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4875 mb_type -= 23; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4876 goto decode_intra_mb; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4877 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4878 } else if( h->slice_type == P_TYPE ) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4879 if( mb_type < 5) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4880 partition_count= p_mb_type_info[mb_type].partition_count; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4881 mb_type= p_mb_type_info[mb_type].type; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4882 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4883 mb_type -= 5; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4884 goto decode_intra_mb; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4885 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4886 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4887 assert(h->slice_type == I_TYPE); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4888 decode_intra_mb: |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4889 partition_count = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4890 cbp= i_mb_type_info[mb_type].cbp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4891 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4892 mb_type= i_mb_type_info[mb_type].type; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4893 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4894 #if 0 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4895 if(h->mb_field_decoding_flag) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4896 mb_type |= MB_TYPE_INTERLACED; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4897 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4898 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4899 s->current_picture.mb_type[mb_xy]= mb_type; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4900 h->slice_table[ mb_xy ]= h->slice_num; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4901 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4902 if(IS_INTRA_PCM(mb_type)) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4903 /* TODO */ |
2314 | 4904 assert(0); |
4905 h->cbp_table[mb_xy] = 0xf +4*2; //FIXME ?! | |
4906 h->cbp_table[mb_xy] |= 0x1C0; | |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4907 h->chroma_pred_mode_table[mb_xy] = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4908 s->current_picture.qscale_table[mb_xy]= s->qscale; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4909 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4910 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4911 |
2449 | 4912 fill_caches(h, mb_type, 0); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4913 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4914 if( IS_INTRA( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4915 if( IS_INTRA4x4( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4916 int i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4917 for( i = 0; i < 16; i++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4918 int pred = pred_intra_mode( h, i ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4919 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4920 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4921 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4922 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4923 write_back_intra_pred_mode(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4924 if( check_intra4x4_pred_mode(h) < 0 ) return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4925 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4926 h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4927 if( h->intra16x16_pred_mode < 0 ) return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4928 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4929 h->chroma_pred_mode_table[mb_xy] = |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4930 h->chroma_pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4931 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4932 h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4933 if( h->chroma_pred_mode < 0 ) return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4934 } else if( partition_count == 4 ) { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4935 int i, j, sub_partition_count[4], list, ref[2][4]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4936 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4937 if( h->slice_type == B_TYPE ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4938 for( i = 0; i < 4; i++ ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4939 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4940 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4941 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4942 } |
2396 | 4943 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
4944 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { | |
4945 pred_direct_motion(h, &mb_type); | |
4946 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
4947 for( i = 0; i < 4; i++ ) | |
4948 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
4949 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
4950 } | |
4951 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4952 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4953 for( i = 0; i < 4; i++ ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4954 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4955 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4956 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4957 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4958 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4959 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4960 for( list = 0; list < 2; list++ ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4961 if( h->ref_count[list] > 0 ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4962 for( i = 0; i < 4; i++ ) { |
2396 | 4963 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
4964 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4965 if( h->ref_count[list] > 1 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4966 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4967 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4968 ref[list][i] = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4969 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4970 ref[list][i] = -1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4971 } |
2110 | 4972 h->ref_cache[list][ scan8[4*i]+1 ]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4973 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4974 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4975 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4976 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4977 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4978 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4979 for(i=0; i<4; i++){ |
2396 | 4980 if(IS_DIRECT(h->sub_mb_type[i])){ |
4981 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
4982 continue; | |
4983 } | |
2110 | 4984 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4985 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4986 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4987 const int sub_mb_type= h->sub_mb_type[i]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4988 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4989 for(j=0; j<sub_partition_count[i]; j++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4990 int mpx, mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4991 int mx, my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4992 const int index= 4*i + block_width*j; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4993 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4994 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4995 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4996 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4997 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4998 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4999 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5000 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5001 if(IS_SUB_8X8(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5002 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5003 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5004 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5005 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5006 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5007 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5008 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5009 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5010 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5011 }else if(IS_SUB_8X4(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5012 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5013 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5014 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5015 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5016 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5017 }else if(IS_SUB_4X8(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5018 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5019 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5020 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5021 mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5022 mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5023 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5024 assert(IS_SUB_4X4(sub_mb_type)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5025 mv_cache[ 0 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5026 mv_cache[ 0 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5027 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5028 mvd_cache[ 0 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5029 mvd_cache[ 0 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5030 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5031 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5032 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5033 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5034 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5035 p[0] = p[1] = p[8] = p[9] = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5036 pd[0]= pd[1]= pd[8]= pd[9]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5037 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5038 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5039 } |
2396 | 5040 } else if( IS_DIRECT(mb_type) ) { |
5041 pred_direct_motion(h, &mb_type); | |
5042 s->current_picture.mb_type[mb_xy]= mb_type; | |
5043 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
5044 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
5045 } else { | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5046 int list, mx, my, i, mpx, mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5047 if(IS_16X16(mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5048 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5049 if(IS_DIR(mb_type, 0, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5050 if(h->ref_count[list] > 0 ){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5051 const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5052 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5053 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5054 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5055 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5056 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5057 if(IS_DIR(mb_type, 0, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5058 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5059 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5060 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5061 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5062 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5063 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5064 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5065 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5066 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5067 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5068 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5069 else if(IS_16X8(mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5070 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5071 if(h->ref_count[list]>0){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5072 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5073 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5074 const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5075 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 5076 }else |
5077 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5078 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5079 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5080 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5081 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5082 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5083 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5084 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5085 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5086 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5087 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5088 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5089 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5090 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5091 }else{ // needed only for mixed refs |
5092 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
5093 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5094 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5095 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5096 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5097 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5098 assert(IS_8X16(mb_type)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5099 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5100 if(h->ref_count[list]>0){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5101 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5102 if(IS_DIR(mb_type, i, list)){ //FIXME optimize |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5103 const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5104 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 5105 }else |
5106 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5107 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5108 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5109 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5110 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5111 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5112 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5113 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5114 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5115 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5116 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5117 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5118 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5119 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5120 }else{ // needed only for mixed refs |
5121 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
5122 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5123 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5124 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5125 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5126 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5127 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5128 |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5129 if( IS_INTER( mb_type ) ) { |
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5130 h->chroma_pred_mode_table[mb_xy] = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5131 write_back_motion( h, mb_type ); |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5132 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5133 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5134 if( !IS_INTRA16x16( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5135 cbp = decode_cabac_mb_cbp_luma( h ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5136 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5137 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5138 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5139 h->cbp_table[mb_xy] = cbp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5140 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5141 if( cbp || IS_INTRA16x16( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5142 const uint8_t *scan, *dc_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5143 int dqp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5144 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5145 if(IS_INTERLACED(mb_type)){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5146 scan= field_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5147 dc_scan= luma_dc_field_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5148 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5149 scan= zigzag_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5150 dc_scan= luma_dc_zigzag_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5151 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5152 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5153 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5154 s->qscale += dqp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5155 if(((unsigned)s->qscale) > 51){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5156 if(s->qscale<0) s->qscale+= 52; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5157 else s->qscale-= 52; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5158 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5159 h->chroma_qp = get_chroma_qp(h, s->qscale); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5160 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5161 if( IS_INTRA16x16( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5162 int i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5163 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5164 if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, s->qscale, 16) < 0) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5165 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5166 if( cbp&15 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5167 for( i = 0; i < 16; i++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5168 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5169 if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, s->qscale, 15) < 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5170 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5171 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5172 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5173 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5174 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5175 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5176 int i8x8, i4x4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5177 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5178 if( cbp & (1<<i8x8) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5179 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5180 const int index = 4*i8x8 + i4x4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5181 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5182 if( decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, s->qscale, 16) < 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5183 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5184 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5185 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5186 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5187 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5188 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5189 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5190 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5191 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5192 if( cbp&0x30 ){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5193 int c; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5194 for( c = 0; c < 2; c++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5195 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5196 if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, h->chroma_qp, 4) < 0) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5197 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5198 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5199 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5200 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5201 if( cbp&0x20 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5202 int c, i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5203 for( c = 0; c < 2; c++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5204 for( i = 0; i < 4; i++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5205 const int index = 16 + 4 * c + i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5206 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5207 if( decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, h->chroma_qp, 15) < 0) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5208 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5209 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5210 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5211 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5212 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5213 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5214 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5215 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5216 } else { |
2315 | 5217 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
5218 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
5219 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5220 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5221 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5222 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5223 s->current_picture.qscale_table[mb_xy]= s->qscale; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5224 write_back_non_zero_count(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5225 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5226 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5227 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5228 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5229 |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5230 static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5231 int i, d; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5232 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5233 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5234 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5235 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5236 for( i = 0; i < 4; i++ ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5237 if( bS[i] == 0 ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5238 pix += 4 * stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5239 continue; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5240 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5241 |
1898 | 5242 if( bS[i] < 4 ) { |
5243 const int tc0 = tc0_table[index_a][bS[i] - 1]; | |
5244 /* 4px edge length */ | |
5245 for( d = 0; d < 4; d++ ) { | |
5246 const int p0 = pix[-1]; | |
5247 const int p1 = pix[-2]; | |
5248 const int p2 = pix[-3]; | |
5249 const int q0 = pix[0]; | |
5250 const int q1 = pix[1]; | |
5251 const int q2 = pix[2]; | |
5252 | |
5253 if( ABS( p0 - q0 ) < alpha && | |
5254 ABS( p1 - p0 ) < beta && | |
5255 ABS( q1 - q0 ) < beta ) { | |
5256 int tc = tc0; | |
5257 int i_delta; | |
5258 | |
5259 if( ABS( p2 - p0 ) < beta ) { | |
5260 pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5261 tc++; | |
5262 } | |
5263 if( ABS( q2 - q0 ) < beta ) { | |
5264 pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5265 tc++; | |
5266 } | |
5267 | |
5268 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5269 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5270 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5271 } |
1898 | 5272 pix += stride; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5273 } |
1898 | 5274 }else{ |
5275 /* 4px edge length */ | |
5276 for( d = 0; d < 4; d++ ) { | |
5277 const int p0 = pix[-1]; | |
5278 const int p1 = pix[-2]; | |
5279 const int p2 = pix[-3]; | |
5280 | |
5281 const int q0 = pix[0]; | |
5282 const int q1 = pix[1]; | |
5283 const int q2 = pix[2]; | |
5284 | |
5285 if( ABS( p0 - q0 ) < alpha && | |
5286 ABS( p1 - p0 ) < beta && | |
5287 ABS( q1 - q0 ) < beta ) { | |
5288 | |
5289 if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
5290 if( ABS( p2 - p0 ) < beta) | |
5291 { | |
5292 const int p3 = pix[-4]; | |
5293 /* p0', p1', p2' */ | |
5294 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
5295 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
5296 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
5297 } else { | |
5298 /* p0' */ | |
5299 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5300 } | |
5301 if( ABS( q2 - q0 ) < beta) | |
5302 { | |
5303 const int q3 = pix[3]; | |
5304 /* q0', q1', q2' */ | |
5305 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
5306 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
5307 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
5308 } else { | |
5309 /* q0' */ | |
5310 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5311 } | |
5312 }else{ | |
5313 /* p0', q0' */ | |
5314 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5315 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5316 } | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5317 } |
1898 | 5318 pix += stride; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5319 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5320 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5321 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5322 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5323 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5324 int i, d; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5325 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5326 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5327 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5328 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5329 for( i = 0; i < 4; i++ ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5330 if( bS[i] == 0 ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5331 pix += 2 * stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5332 continue; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5333 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5334 |
1898 | 5335 if( bS[i] < 4 ) { |
5336 const int tc = tc0_table[index_a][bS[i] - 1] + 1; | |
5337 /* 2px edge length (because we use same bS than the one for luma) */ | |
5338 for( d = 0; d < 2; d++ ){ | |
5339 const int p0 = pix[-1]; | |
5340 const int p1 = pix[-2]; | |
5341 const int q0 = pix[0]; | |
5342 const int q1 = pix[1]; | |
5343 | |
5344 if( ABS( p0 - q0 ) < alpha && | |
5345 ABS( p1 - p0 ) < beta && | |
5346 ABS( q1 - q0 ) < beta ) { | |
5347 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5348 | |
5349 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5350 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
5351 //tprintf("filter_mb_edgecv i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, tc, bS[i], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1); |
1898 | 5352 } |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5353 pix += stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5354 } |
1898 | 5355 }else{ |
5356 /* 2px edge length (because we use same bS than the one for luma) */ | |
5357 for( d = 0; d < 2; d++ ){ | |
5358 const int p0 = pix[-1]; | |
5359 const int p1 = pix[-2]; | |
5360 const int q0 = pix[0]; | |
5361 const int q1 = pix[1]; | |
5362 | |
5363 if( ABS( p0 - q0 ) < alpha && | |
5364 ABS( p1 - p0 ) < beta && | |
5365 ABS( q1 - q0 ) < beta ) { | |
5366 | |
5367 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */ | |
5368 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
5369 //tprintf("filter_mb_edgecv i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1); |
1898 | 5370 } |
5371 pix += stride; | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5372 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5373 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5374 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5375 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5376 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5377 static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5378 int i, d; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5379 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5380 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5381 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5382 const int pix_next = stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5383 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5384 for( i = 0; i < 4; i++ ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5385 if( bS[i] == 0 ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5386 pix += 4; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5387 continue; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5388 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5389 |
1898 | 5390 if( bS[i] < 4 ) { |
5391 const int tc0 = tc0_table[index_a][bS[i] - 1]; | |
5392 /* 4px edge length */ | |
5393 for( d = 0; d < 4; d++ ) { | |
5394 const int p0 = pix[-1*pix_next]; | |
5395 const int p1 = pix[-2*pix_next]; | |
5396 const int p2 = pix[-3*pix_next]; | |
5397 const int q0 = pix[0]; | |
5398 const int q1 = pix[1*pix_next]; | |
5399 const int q2 = pix[2*pix_next]; | |
5400 | |
5401 if( ABS( p0 - q0 ) < alpha && | |
5402 ABS( p1 - p0 ) < beta && | |
5403 ABS( q1 - q0 ) < beta ) { | |
5404 | |
5405 int tc = tc0; | |
5406 int i_delta; | |
5407 | |
5408 if( ABS( p2 - p0 ) < beta ) { | |
5409 pix[-2*pix_next] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5410 tc++; | |
5411 } | |
5412 if( ABS( q2 - q0 ) < beta ) { | |
5413 pix[pix_next] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5414 tc++; | |
5415 } | |
5416 | |
5417 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5418 pix[-pix_next] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5419 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5420 } |
1898 | 5421 pix++; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5422 } |
1898 | 5423 }else{ |
5424 /* 4px edge length */ | |
5425 for( d = 0; d < 4; d++ ) { | |
5426 const int p0 = pix[-1*pix_next]; | |
5427 const int p1 = pix[-2*pix_next]; | |
5428 const int p2 = pix[-3*pix_next]; | |
5429 const int q0 = pix[0]; | |
5430 const int q1 = pix[1*pix_next]; | |
5431 const int q2 = pix[2*pix_next]; | |
5432 | |
5433 if( ABS( p0 - q0 ) < alpha && | |
5434 ABS( p1 - p0 ) < beta && | |
5435 ABS( q1 - q0 ) < beta ) { | |
5436 | |
5437 const int p3 = pix[-4*pix_next]; | |
5438 const int q3 = pix[ 3*pix_next]; | |
5439 | |
5440 if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
5441 if( ABS( p2 - p0 ) < beta) { | |
5442 /* p0', p1', p2' */ | |
5443 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
5444 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
5445 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
5446 } else { | |
5447 /* p0' */ | |
5448 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5449 } | |
5450 if( ABS( q2 - q0 ) < beta) { | |
5451 /* q0', q1', q2' */ | |
5452 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
5453 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
5454 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
5455 } else { | |
5456 /* q0' */ | |
5457 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5458 } | |
5459 }else{ | |
5460 /* p0', q0' */ | |
5461 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5462 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5463 } | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5464 } |
1898 | 5465 pix++; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5466 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5467 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5468 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5469 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5470 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5471 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5472 int i, d; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5473 const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5474 const int alpha = alpha_table[index_a]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5475 const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5476 const int pix_next = stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5477 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5478 for( i = 0; i < 4; i++ ) |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5479 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5480 if( bS[i] == 0 ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5481 pix += 2; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5482 continue; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5483 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5484 |
1898 | 5485 if( bS[i] < 4 ) { |
5486 int tc = tc0_table[index_a][bS[i] - 1] + 1; | |
5487 /* 2px edge length (see deblocking_filter_edgecv) */ | |
5488 for( d = 0; d < 2; d++ ) { | |
5489 const int p0 = pix[-1*pix_next]; | |
5490 const int p1 = pix[-2*pix_next]; | |
5491 const int q0 = pix[0]; | |
5492 const int q1 = pix[1*pix_next]; | |
5493 | |
5494 if( ABS( p0 - q0 ) < alpha && | |
5495 ABS( p1 - p0 ) < beta && | |
5496 ABS( q1 - q0 ) < beta ) { | |
5497 | |
5498 int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5499 | |
5500 pix[-pix_next] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5501 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ | |
5502 } | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5503 pix++; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5504 } |
1898 | 5505 }else{ |
5506 /* 2px edge length (see deblocking_filter_edgecv) */ | |
5507 for( d = 0; d < 2; d++ ) { | |
5508 const int p0 = pix[-1*pix_next]; | |
5509 const int p1 = pix[-2*pix_next]; | |
5510 const int q0 = pix[0]; | |
5511 const int q1 = pix[1*pix_next]; | |
5512 | |
5513 if( ABS( p0 - q0 ) < alpha && | |
5514 ABS( p1 - p0 ) < beta && | |
5515 ABS( q1 - q0 ) < beta ) { | |
5516 | |
5517 pix[-pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */ | |
5518 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ | |
5519 } | |
5520 pix++; | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5521 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5522 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5523 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5524 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5525 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5526 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5527 MpegEncContext * const s = &h->s; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5528 const int mb_xy= mb_x + mb_y*s->mb_stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5529 int linesize, uvlinesize; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5530 int dir; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5531 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5532 /* FIXME Implement deblocking filter for field MB */ |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5533 if( h->sps.mb_aff ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5534 return; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5535 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5536 linesize = s->linesize; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5537 uvlinesize = s->uvlinesize; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5538 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5539 /* dir : 0 -> vertical edge, 1 -> horizontal edge */ |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5540 for( dir = 0; dir < 2; dir++ ) |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5541 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5542 int edge; |
2454 | 5543 const int mbm_xy = dir == 0 ? mb_xy -1 : mb_xy - s->mb_stride; |
5544 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; | |
5545 | |
5546 if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy]) | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5547 start = 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5548 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5549 /* Calculate bS */ |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5550 for( edge = start; edge < 4; edge++ ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5551 /* mbn_xy: neighbour macroblock (how that works for field ?) */ |
2454 | 5552 int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5553 int bS[4]; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5554 int qp; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5555 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5556 if( IS_INTRA( s->current_picture.mb_type[mb_xy] ) || |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5557 IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5558 bS[0] = bS[1] = bS[2] = bS[3] = ( edge == 0 ? 4 : 3 ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5559 } else { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5560 int i; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5561 for( i = 0; i < 4; i++ ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5562 int x = dir == 0 ? edge : i; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5563 int y = dir == 0 ? i : edge; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5564 int b_idx= 8 + 4 + x + 8*y; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5565 int bn_idx= b_idx - (dir ? 8:1); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5566 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5567 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 5568 h->non_zero_count_cache[bn_idx] != 0 ) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5569 bS[i] = 2; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5570 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5571 else if( h->slice_type == P_TYPE ) { |
2449 | 5572 if( h->ref_cache[0][b_idx] != h->ref_cache[0][bn_idx] || |
5573 ABS( h->mv_cache[0][b_idx][0] - h->mv_cache[0][bn_idx][0] ) >= 4 || | |
5574 ABS( h->mv_cache[0][b_idx][1] - h->mv_cache[0][bn_idx][1] ) >= 4 ) | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5575 bS[i] = 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5576 else |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5577 bS[i] = 0; |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
5578 } else { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5579 /* FIXME Add support for B frame */ |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5580 return; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5581 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5582 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5583 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5584 if(bS[0]+bS[1]+bS[2]+bS[3] == 0) |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5585 continue; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5586 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5587 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5588 /* Filter edge */ |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5589 qp = ( s->qscale + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
5590 //tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5591 if( dir == 0 ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5592 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 5593 if( (edge&1) == 0 ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5594 int chroma_qp = ( h->chroma_qp + |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5595 get_chroma_qp( h, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5596 filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_qp ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5597 filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_qp ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5598 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5599 } else { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5600 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 5601 if( (edge&1) == 0 ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5602 int chroma_qp = ( h->chroma_qp + |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5603 get_chroma_qp( h, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5604 filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_qp ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5605 filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_qp ); |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5606 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5607 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5608 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5609 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5610 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5611 |
1168 | 5612 static int decode_slice(H264Context *h){ |
5613 MpegEncContext * const s = &h->s; | |
5614 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
5615 | |
5616 s->mb_skip_run= -1; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5617 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5618 if( h->pps.cabac ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5619 int i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5620 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5621 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5622 align_get_bits( &s->gb ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5623 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5624 /* init cabac */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5625 ff_init_cabac_states( &h->cabac, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5626 ff_init_cabac_decoder( &h->cabac, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5627 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 5628 ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5629 /* calculate pre-state */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5630 for( i= 0; i < 399; i++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5631 int pre; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5632 if( h->slice_type == I_TYPE ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5633 pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5634 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5635 pre = clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5636 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5637 if( pre <= 63 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5638 h->cabac_state[i] = 2 * ( 63 - pre ) + 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5639 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5640 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 5641 } |
5642 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5643 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5644 int ret = decode_mb_cabac(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5645 int eos = get_cabac_terminate( &h->cabac ); /* End of Slice flag */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5646 |
2163 | 5647 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5648 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5649 /* XXX: useless as decode_mb_cabac it doesn't support that ... */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5650 if( ret >= 0 && h->sps.mb_aff ) { //FIXME optimal? or let mb_decode decode 16x32 ? |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5651 s->mb_y++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5652 |
2163 | 5653 if(ret>=0) ret = decode_mb_cabac(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5654 eos = get_cabac_terminate( &h->cabac ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5655 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5656 hl_decode_mb(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5657 s->mb_y--; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5658 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5659 |
2116 | 5660 if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 1) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5661 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5662 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5663 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5664 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5665 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5666 if( ++s->mb_x >= s->mb_width ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5667 s->mb_x = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5668 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 5669 ++s->mb_y; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5670 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5671 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5672 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 5673 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5674 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5675 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5676 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5677 #if 0 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5678 /* TODO test over-reading in cabac code */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5679 else if( read too much in h->cabac ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5680 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5681 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5682 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5683 #endif |
1168 | 5684 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5685 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5686 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5687 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5688 int ret = decode_mb_cavlc(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5689 |
2163 | 5690 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5691 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5692 if(ret>=0 && h->sps.mb_aff){ //FIXME optimal? or let mb_decode decode 16x32 ? |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5693 s->mb_y++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5694 ret = decode_mb_cavlc(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5695 |
2163 | 5696 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5697 s->mb_y--; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5698 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5699 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5700 if(ret<0){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5701 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5702 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5703 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5704 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5705 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5706 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5707 if(++s->mb_x >= s->mb_width){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5708 s->mb_x=0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5709 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5710 if(++s->mb_y >= s->mb_height){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5711 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5712 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5713 if(get_bits_count(&s->gb) == s->gb.size_in_bits ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5714 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5715 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5716 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5717 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5718 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5719 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5720 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5721 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5722 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5723 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5724 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5725 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 5726 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5727 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 5728 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
5729 | |
5730 return 0; | |
5731 }else{ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5732 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
1168 | 5733 |
5734 return -1; | |
5735 } | |
5736 } | |
5737 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5738 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5739 |
1168 | 5740 #if 0 |
5741 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
5742 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
5743 int ret= decode_mb(h); | |
5744 | |
5745 hl_decode_mb(h); | |
5746 | |
5747 if(ret<0){ | |
5748 fprintf(stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); | |
5749 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); | |
5750 | |
5751 return -1; | |
5752 } | |
5753 | |
5754 if(++s->mb_x >= s->mb_width){ | |
5755 s->mb_x=0; | |
5756 if(++s->mb_y >= s->mb_height){ | |
5757 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
5758 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); | |
5759 | |
5760 return 0; | |
5761 }else{ | |
5762 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); | |
5763 | |
5764 return -1; | |
5765 } | |
5766 } | |
5767 } | |
5768 | |
5769 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ | |
5770 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
5771 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); | |
5772 | |
5773 return 0; | |
5774 }else{ | |
5775 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); | |
5776 | |
5777 return -1; | |
5778 } | |
5779 } | |
5780 } | |
5781 s->mb_x=0; | |
5782 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
5783 } | |
5784 #endif | |
5785 return -1; //not reached | |
5786 } | |
5787 | |
5788 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ | |
5789 MpegEncContext * const s = &h->s; | |
5790 int aspect_ratio_info_present_flag, aspect_ratio_idc; | |
5791 | |
5792 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
5793 | |
5794 if( aspect_ratio_info_present_flag ) { | |
5795 aspect_ratio_idc= get_bits(&s->gb, 8); | |
5796 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 5797 sps->sar.num= get_bits(&s->gb, 16); |
5798 sps->sar.den= get_bits(&s->gb, 16); | |
1168 | 5799 }else if(aspect_ratio_idc < 16){ |
1548 | 5800 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 5801 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5802 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 5803 return -1; |
5804 } | |
5805 }else{ | |
1548 | 5806 sps->sar.num= |
5807 sps->sar.den= 0; | |
1168 | 5808 } |
5809 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height); | |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5810 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5811 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5812 get_bits1(&s->gb); /* overscan_appropriate_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5813 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5814 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5815 if(get_bits1(&s->gb)){ /* video_signal_type_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5816 get_bits(&s->gb, 3); /* video_format */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5817 get_bits1(&s->gb); /* video_full_range_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5818 if(get_bits1(&s->gb)){ /* colour_description_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5819 get_bits(&s->gb, 8); /* colour_primaries */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5820 get_bits(&s->gb, 8); /* transfer_characteristics */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5821 get_bits(&s->gb, 8); /* matrix_coefficients */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5822 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5823 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5824 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5825 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5826 get_ue_golomb(&s->gb); /* chroma_sample_location_type_top_field */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5827 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5828 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5829 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5830 sps->timing_info_present_flag = get_bits1(&s->gb); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5831 if(sps->timing_info_present_flag){ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5832 sps->num_units_in_tick = get_bits_long(&s->gb, 32); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5833 sps->time_scale = get_bits_long(&s->gb, 32); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5834 sps->fixed_frame_rate_flag = get_bits1(&s->gb); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5835 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5836 |
1168 | 5837 #if 0 |
5838 | nal_hrd_parameters_present_flag |0 |u(1) | | |
5839 | if( nal_hrd_parameters_present_flag = = 1) | | | | |
5840 | hrd_parameters( ) | | | | |
5841 | vcl_hrd_parameters_present_flag |0 |u(1) | | |
5842 | if( vcl_hrd_parameters_present_flag = = 1) | | | | |
5843 | hrd_parameters( ) | | | | |
5844 | if( ( nal_hrd_parameters_present_flag = = 1 | || | | | |
5845 | | | | | |
5846 |( vcl_hrd_parameters_present_flag = = 1 ) ) | | | | |
5847 | low_delay_hrd_flag |0 |u(1) | | |
5848 | bitstream_restriction_flag |0 |u(1) | | |
5849 | if( bitstream_restriction_flag ) { |0 |u(1) | | |
5850 | motion_vectors_over_pic_boundaries_flag |0 |u(1) | | |
5851 | max_bytes_per_pic_denom |0 |ue(v) | | |
5852 | max_bits_per_mb_denom |0 |ue(v) | | |
5853 | log2_max_mv_length_horizontal |0 |ue(v) | | |
5854 | log2_max_mv_length_vertical |0 |ue(v) | | |
5855 | num_reorder_frames |0 |ue(v) | | |
5856 | max_dec_frame_buffering |0 |ue(v) | | |
5857 | } | | | | |
5858 |} | | | | |
5859 #endif | |
5860 return 0; | |
5861 } | |
5862 | |
5863 static inline int decode_seq_parameter_set(H264Context *h){ | |
5864 MpegEncContext * const s = &h->s; | |
1371 | 5865 int profile_idc, level_idc; |
1168 | 5866 int sps_id, i; |
5867 SPS *sps; | |
5868 | |
5869 profile_idc= get_bits(&s->gb, 8); | |
1371 | 5870 get_bits1(&s->gb); //constraint_set0_flag |
5871 get_bits1(&s->gb); //constraint_set1_flag | |
5872 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 5873 get_bits1(&s->gb); //constraint_set3_flag |
5874 get_bits(&s->gb, 4); // reserved | |
1168 | 5875 level_idc= get_bits(&s->gb, 8); |
5876 sps_id= get_ue_golomb(&s->gb); | |
5877 | |
5878 sps= &h->sps_buffer[ sps_id ]; | |
5879 sps->profile_idc= profile_idc; | |
5880 sps->level_idc= level_idc; | |
2312 | 5881 |
1168 | 5882 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
5883 sps->poc_type= get_ue_golomb(&s->gb); | |
5884 | |
5885 if(sps->poc_type == 0){ //FIXME #define | |
5886 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
5887 } else if(sps->poc_type == 1){//FIXME #define | |
5888 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
5889 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
5890 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
5891 sps->poc_cycle_length= get_ue_golomb(&s->gb); | |
5892 | |
5893 for(i=0; i<sps->poc_cycle_length; i++) | |
5894 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
5895 } | |
5896 if(sps->poc_type > 2){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5897 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 5898 return -1; |
5899 } | |
5900 | |
5901 sps->ref_frame_count= get_ue_golomb(&s->gb); | |
2254
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
5902 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){ |
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
5903 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n"); |
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
5904 } |
1371 | 5905 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
1168 | 5906 sps->mb_width= get_ue_golomb(&s->gb) + 1; |
5907 sps->mb_height= get_ue_golomb(&s->gb) + 1; | |
2422 | 5908 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 || |
5909 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)) | |
5910 return -1; | |
5911 | |
1168 | 5912 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
5913 if(!sps->frame_mbs_only_flag) | |
5914 sps->mb_aff= get_bits1(&s->gb); | |
5915 else | |
5916 sps->mb_aff= 0; | |
5917 | |
5918 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
5919 | |
1371 | 5920 sps->crop= get_bits1(&s->gb); |
5921 if(sps->crop){ | |
5922 sps->crop_left = get_ue_golomb(&s->gb); | |
5923 sps->crop_right = get_ue_golomb(&s->gb); | |
5924 sps->crop_top = get_ue_golomb(&s->gb); | |
5925 sps->crop_bottom= get_ue_golomb(&s->gb); | |
5926 if(sps->crop_left || sps->crop_top){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5927 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completly supported, this could look slightly wrong ...\n"); |
1371 | 5928 } |
5929 }else{ | |
5930 sps->crop_left = | |
5931 sps->crop_right = | |
5932 sps->crop_top = | |
5933 sps->crop_bottom= 0; | |
5934 } | |
5935 | |
1168 | 5936 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
5937 if( sps->vui_parameters_present_flag ) | |
5938 decode_vui_parameters(h, sps); | |
5939 | |
5940 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5941 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n", |
1168 | 5942 sps_id, sps->profile_idc, sps->level_idc, |
5943 sps->poc_type, | |
5944 sps->ref_frame_count, | |
5945 sps->mb_width, sps->mb_height, | |
5946 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
5947 sps->direct_8x8_inference_flag ? "8B8" : "", | |
1371 | 5948 sps->crop_left, sps->crop_right, |
5949 sps->crop_top, sps->crop_bottom, | |
1168 | 5950 sps->vui_parameters_present_flag ? "VUI" : "" |
5951 ); | |
5952 } | |
5953 return 0; | |
5954 } | |
5955 | |
5956 static inline int decode_picture_parameter_set(H264Context *h){ | |
5957 MpegEncContext * const s = &h->s; | |
5958 int pps_id= get_ue_golomb(&s->gb); | |
5959 PPS *pps= &h->pps_buffer[pps_id]; | |
5960 | |
5961 pps->sps_id= get_ue_golomb(&s->gb); | |
5962 pps->cabac= get_bits1(&s->gb); | |
5963 pps->pic_order_present= get_bits1(&s->gb); | |
5964 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
5965 if(pps->slice_group_count > 1 ){ | |
5966 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb); | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5967 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 5968 switch(pps->mb_slice_group_map_type){ |
5969 case 0: | |
5970 #if 0 | |
5971 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
5972 | run_length[ i ] |1 |ue(v) | | |
5973 #endif | |
5974 break; | |
5975 case 2: | |
5976 #if 0 | |
5977 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
5978 |{ | | | | |
5979 | top_left_mb[ i ] |1 |ue(v) | | |
5980 | bottom_right_mb[ i ] |1 |ue(v) | | |
5981 | } | | | | |
5982 #endif | |
5983 break; | |
5984 case 3: | |
5985 case 4: | |
5986 case 5: | |
5987 #if 0 | |
5988 | slice_group_change_direction_flag |1 |u(1) | | |
5989 | slice_group_change_rate_minus1 |1 |ue(v) | | |
5990 #endif | |
5991 break; | |
5992 case 6: | |
5993 #if 0 | |
5994 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
5995 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
5996 |) | | | | |
5997 | slice_group_id[ i ] |1 |u(v) | | |
5998 #endif | |
1214 | 5999 break; |
1168 | 6000 } |
6001 } | |
6002 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
6003 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
6004 if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6005 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
1168 | 6006 return -1; |
6007 } | |
6008 | |
6009 pps->weighted_pred= get_bits1(&s->gb); | |
6010 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
6011 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
6012 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
6013 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
6014 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
6015 pps->constrained_intra_pred= get_bits1(&s->gb); | |
6016 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
6017 | |
6018 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6019 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s\n", |
1168 | 6020 pps_id, pps->sps_id, |
6021 pps->cabac ? "CABAC" : "CAVLC", | |
6022 pps->slice_group_count, | |
6023 pps->ref_count[0], pps->ref_count[1], | |
6024 pps->weighted_pred ? "weighted" : "", | |
6025 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
6026 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
6027 pps->constrained_intra_pred ? "CONSTR" : "", | |
1371 | 6028 pps->redundant_pic_cnt_present ? "REDU" : "" |
1168 | 6029 ); |
6030 } | |
6031 | |
6032 return 0; | |
6033 } | |
6034 | |
6035 /** | |
6036 * finds the end of the current frame in the bitstream. | |
6037 * @return the position of the first byte of the next frame, or -1 | |
6038 */ | |
2392 | 6039 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 6040 int i; |
1168 | 6041 uint32_t state; |
2392 | 6042 ParseContext *pc = &(h->s.parse_context); |
1168 | 6043 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
6044 // mb_addr= pc->mb_addr - 1; | |
6045 state= pc->state; | |
2392 | 6046 for(i=0; i<=buf_size; i++){ |
1168 | 6047 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 6048 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 6049 if(pc->frame_start_found){ |
2392 | 6050 // If there isn't one more byte in the buffer |
6051 // the test on first_mb_in_slice cannot be done yet | |
6052 // do it at next call. | |
6053 if (i >= buf_size) break; | |
6054 if (buf[i] & 0x80) { | |
6055 // first_mb_in_slice is 0, probably the first nal of a new | |
6056 // slice | |
6057 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
6058 pc->state=-1; | |
6059 pc->frame_start_found= 0; | |
6060 return i-4; | |
6061 } | |
1168 | 6062 } |
2392 | 6063 pc->frame_start_found = 1; |
1168 | 6064 } |
2392 | 6065 if (i<buf_size) |
6066 state= (state<<8) | buf[i]; | |
1168 | 6067 } |
6068 | |
6069 pc->state= state; | |
1219 | 6070 return END_NOT_FOUND; |
1168 | 6071 } |
6072 | |
1988 | 6073 static int h264_parse(AVCodecParserContext *s, |
6074 AVCodecContext *avctx, | |
6075 uint8_t **poutbuf, int *poutbuf_size, | |
6076 const uint8_t *buf, int buf_size) | |
6077 { | |
2392 | 6078 H264Context *h = s->priv_data; |
6079 ParseContext *pc = &h->s.parse_context; | |
1988 | 6080 int next; |
6081 | |
2392 | 6082 next= find_frame_end(h, buf, buf_size); |
1988 | 6083 |
6084 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
6085 *poutbuf = NULL; | |
6086 *poutbuf_size = 0; | |
6087 return buf_size; | |
6088 } | |
6089 | |
6090 *poutbuf = (uint8_t *)buf; | |
6091 *poutbuf_size = buf_size; | |
6092 return next; | |
6093 } | |
6094 | |
1168 | 6095 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
6096 MpegEncContext * const s = &h->s; | |
6097 AVCodecContext * const avctx= s->avctx; | |
6098 int buf_index=0; | |
1322 | 6099 #if 0 |
1168 | 6100 int i; |
6101 for(i=0; i<32; i++){ | |
6102 printf("%X ", buf[i]); | |
6103 } | |
6104 #endif | |
2392 | 6105 h->slice_num = 0; |
1168 | 6106 for(;;){ |
6107 int consumed; | |
6108 int dst_length; | |
6109 int bit_length; | |
6110 uint8_t *ptr; | |
2227 | 6111 int i, nalsize = 0; |
1168 | 6112 |
2227 | 6113 if(h->is_avc) { |
6114 if(buf_index >= buf_size) break; | |
6115 nalsize = 0; | |
6116 for(i = 0; i < h->nal_length_size; i++) | |
6117 nalsize = (nalsize << 8) | buf[buf_index++]; | |
6118 } else { | |
1168 | 6119 // start code prefix search |
6120 for(; buf_index + 3 < buf_size; buf_index++){ | |
6121 // this should allways succeed in the first iteration | |
6122 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
6123 break; | |
6124 } | |
6125 | |
6126 if(buf_index+3 >= buf_size) break; | |
6127 | |
6128 buf_index+=3; | |
2227 | 6129 } |
1168 | 6130 |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
6131 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
1168 | 6132 if(ptr[dst_length - 1] == 0) dst_length--; |
6133 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); | |
6134 | |
6135 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
6136 av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", h->nal_unit_type, buf_index, buf_size, dst_length); |
1168 | 6137 } |
6138 | |
2227 | 6139 if (h->is_avc && (nalsize != consumed)) |
6140 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
6141 | |
1168 | 6142 buf_index += consumed; |
6143 | |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
6144 if( s->hurry_up == 1 && h->nal_ref_idc == 0 ) |
1168 | 6145 continue; |
6146 | |
6147 switch(h->nal_unit_type){ | |
6148 case NAL_IDR_SLICE: | |
6149 idr(h); //FIXME ensure we dont loose some frames if there is reordering | |
6150 case NAL_SLICE: | |
6151 init_get_bits(&s->gb, ptr, bit_length); | |
6152 h->intra_gb_ptr= | |
6153 h->inter_gb_ptr= &s->gb; | |
6154 s->data_partitioning = 0; | |
6155 | |
6156 if(decode_slice_header(h) < 0) return -1; | |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
6157 if(h->redundant_pic_count==0 && s->hurry_up < 5 ) |
1168 | 6158 decode_slice(h); |
6159 break; | |
6160 case NAL_DPA: | |
6161 init_get_bits(&s->gb, ptr, bit_length); | |
6162 h->intra_gb_ptr= | |
6163 h->inter_gb_ptr= NULL; | |
6164 s->data_partitioning = 1; | |
6165 | |
6166 if(decode_slice_header(h) < 0) return -1; | |
6167 break; | |
6168 case NAL_DPB: | |
6169 init_get_bits(&h->intra_gb, ptr, bit_length); | |
6170 h->intra_gb_ptr= &h->intra_gb; | |
6171 break; | |
6172 case NAL_DPC: | |
6173 init_get_bits(&h->inter_gb, ptr, bit_length); | |
6174 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 6175 |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
6176 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning && s->hurry_up < 5 ) |
1168 | 6177 decode_slice(h); |
6178 break; | |
6179 case NAL_SEI: | |
6180 break; | |
6181 case NAL_SPS: | |
6182 init_get_bits(&s->gb, ptr, bit_length); | |
6183 decode_seq_parameter_set(h); | |
6184 | |
6185 if(s->flags& CODEC_FLAG_LOW_DELAY) | |
6186 s->low_delay=1; | |
6187 | |
6188 avctx->has_b_frames= !s->low_delay; | |
6189 break; | |
6190 case NAL_PPS: | |
6191 init_get_bits(&s->gb, ptr, bit_length); | |
6192 | |
6193 decode_picture_parameter_set(h); | |
6194 | |
6195 break; | |
6196 case NAL_PICTURE_DELIMITER: | |
6197 break; | |
6198 case NAL_FILTER_DATA: | |
6199 break; | |
2099 | 6200 default: |
6201 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
1168 | 6202 } |
6203 | |
6204 //FIXME move after where irt is set | |
6205 s->current_picture.pict_type= s->pict_type; | |
6206 s->current_picture.key_frame= s->pict_type == I_TYPE; | |
6207 } | |
6208 | |
1174 | 6209 if(!s->current_picture_ptr) return buf_index; //no frame |
6210 | |
1168 | 6211 h->prev_frame_num_offset= h->frame_num_offset; |
6212 h->prev_frame_num= h->frame_num; | |
6213 if(s->current_picture_ptr->reference){ | |
6214 h->prev_poc_msb= h->poc_msb; | |
6215 h->prev_poc_lsb= h->poc_lsb; | |
6216 } | |
6217 if(s->current_picture_ptr->reference) | |
6218 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
6219 | |
6220 ff_er_frame_end(s); | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6221 |
1168 | 6222 MPV_frame_end(s); |
6223 | |
6224 return buf_index; | |
6225 } | |
6226 | |
6227 /** | |
6228 * retunrs the number of bytes consumed for building the current frame | |
6229 */ | |
6230 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
6231 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
6232 pos -= s->parse_context.last_index; | |
6233 if(pos<0) pos=0; // FIXME remove (uneeded?) | |
6234 | |
6235 return pos; | |
6236 }else{ | |
6237 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
6238 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
6239 | |
6240 return pos; | |
6241 } | |
6242 } | |
6243 | |
6244 static int decode_frame(AVCodecContext *avctx, | |
6245 void *data, int *data_size, | |
6246 uint8_t *buf, int buf_size) | |
6247 { | |
6248 H264Context *h = avctx->priv_data; | |
6249 MpegEncContext *s = &h->s; | |
6250 AVFrame *pict = data; | |
6251 int buf_index; | |
6252 | |
6253 s->flags= avctx->flags; | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
6254 s->flags2= avctx->flags2; |
1168 | 6255 |
6256 /* no supplementary picture */ | |
6257 if (buf_size == 0) { | |
6258 return 0; | |
6259 } | |
6260 | |
6261 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
2392 | 6262 int next= find_frame_end(h, buf, buf_size); |
1168 | 6263 |
1988 | 6264 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 6265 return buf_size; |
6266 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
6267 } | |
6268 | |
2227 | 6269 if(h->is_avc && !h->got_avcC) { |
6270 int i, cnt, nalsize; | |
6271 unsigned char *p = avctx->extradata; | |
6272 if(avctx->extradata_size < 7) { | |
6273 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
6274 return -1; | |
6275 } | |
6276 if(*p != 1) { | |
6277 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
6278 return -1; | |
6279 } | |
6280 /* sps and pps in the avcC always have length coded with 2 bytes, | |
6281 so put a fake nal_length_size = 2 while parsing them */ | |
6282 h->nal_length_size = 2; | |
6283 // Decode sps from avcC | |
6284 cnt = *(p+5) & 0x1f; // Number of sps | |
6285 p += 6; | |
6286 for (i = 0; i < cnt; i++) { | |
6287 nalsize = BE_16(p) + 2; | |
6288 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
6289 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); | |
6290 return -1; | |
6291 } | |
6292 p += nalsize; | |
6293 } | |
6294 // Decode pps from avcC | |
6295 cnt = *(p++); // Number of pps | |
6296 for (i = 0; i < cnt; i++) { | |
6297 nalsize = BE_16(p) + 2; | |
6298 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
6299 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
6300 return -1; | |
6301 } | |
6302 p += nalsize; | |
6303 } | |
6304 // Now store right nal length size, that will be use to parse all other nals | |
6305 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
6306 // Do not reparse avcC | |
6307 h->got_avcC = 1; | |
6308 } | |
6309 | |
6310 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){ | |
1168 | 6311 if(0 < decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) ) |
6312 return -1; | |
6313 } | |
6314 | |
6315 buf_index=decode_nal_units(h, buf, buf_size); | |
6316 if(buf_index < 0) | |
6317 return -1; | |
6318 | |
6319 //FIXME do something with unavailable reference frames | |
6320 | |
6321 // if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_index, buf_size); | |
1174 | 6322 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6323 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 6324 return -1; |
6325 } | |
6326 | |
2409 | 6327 { |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
6328 //#define DECODE_ORDER |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
6329 Picture *out = s->current_picture_ptr; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
6330 #ifndef DECODE_ORDER |
2409 | 6331 /* Sort B-frames into display order |
6332 * FIXME doesn't allow for multiple delayed frames */ | |
6333 Picture *cur = s->current_picture_ptr; | |
6334 Picture *prev = h->delayed_pic[0]; | |
6335 | |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6336 if(s->low_delay |
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6337 && (cur->pict_type == B_TYPE |
2409 | 6338 || (!h->sps.gaps_in_frame_num_allowed_flag |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6339 && prev && cur->poc - prev->poc > 2))){ |
2409 | 6340 s->low_delay = 0; |
6341 s->avctx->has_b_frames = 1; | |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6342 if(prev && prev->poc > cur->poc) |
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6343 // too late to display this frame |
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6344 cur = prev; |
2409 | 6345 } |
6346 | |
6347 if(s->low_delay || !prev || cur->pict_type == B_TYPE) | |
6348 out = cur; | |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6349 else |
2409 | 6350 out = prev; |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6351 if(s->low_delay || !prev || out == prev){ |
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6352 if(prev && prev->reference == 1) |
2409 | 6353 prev->reference = 0; |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6354 h->delayed_pic[0] = cur; |
2409 | 6355 } |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
6356 #endif |
2409 | 6357 |
6358 *pict= *(AVFrame*)out; | |
6359 } | |
6360 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1698
diff
changeset
|
6361 ff_print_debug_info(s, pict); |
1168 | 6362 assert(pict->data[0]); |
6363 //printf("out %d\n", (int)pict->data[0]); | |
6364 #if 0 //? | |
6365 | |
6366 /* Return the Picture timestamp as the frame number */ | |
6367 /* we substract 1 because it is added on utils.c */ | |
6368 avctx->frame_number = s->picture_number - 1; | |
6369 #endif | |
6370 #if 0 | |
6371 /* dont output the last pic after seeking */ | |
6372 if(s->last_picture_ptr || s->low_delay) | |
2392 | 6373 //Note this isnt a issue as a IDR pic should flush the buffers |
1168 | 6374 #endif |
6375 *data_size = sizeof(AVFrame); | |
6376 return get_consumed_bytes(s, buf_index, buf_size); | |
6377 } | |
6378 #if 0 | |
6379 static inline void fill_mb_avail(H264Context *h){ | |
6380 MpegEncContext * const s = &h->s; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
6381 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 6382 |
6383 if(s->mb_y){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
6384 h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
6385 h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1174
diff
changeset
|
6386 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 6387 }else{ |
6388 h->mb_avail[0]= | |
6389 h->mb_avail[1]= | |
6390 h->mb_avail[2]= 0; | |
6391 } | |
6392 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
6393 h->mb_avail[4]= 1; //FIXME move out | |
6394 h->mb_avail[5]= 0; //FIXME move out | |
6395 } | |
6396 #endif | |
6397 | |
6398 #if 0 //selftest | |
6399 #define COUNT 8000 | |
6400 #define SIZE (COUNT*40) | |
6401 int main(){ | |
6402 int i; | |
6403 uint8_t temp[SIZE]; | |
6404 PutBitContext pb; | |
6405 GetBitContext gb; | |
6406 // int int_temp[10000]; | |
6407 DSPContext dsp; | |
6408 AVCodecContext avctx; | |
6409 | |
6410 dsputil_init(&dsp, &avctx); | |
6411 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
6412 init_put_bits(&pb, temp, SIZE); |
1168 | 6413 printf("testing unsigned exp golomb\n"); |
6414 for(i=0; i<COUNT; i++){ | |
6415 START_TIMER | |
6416 set_ue_golomb(&pb, i); | |
6417 STOP_TIMER("set_ue_golomb"); | |
6418 } | |
6419 flush_put_bits(&pb); | |
6420 | |
6421 init_get_bits(&gb, temp, 8*SIZE); | |
6422 for(i=0; i<COUNT; i++){ | |
6423 int j, s; | |
6424 | |
6425 s= show_bits(&gb, 24); | |
6426 | |
6427 START_TIMER | |
6428 j= get_ue_golomb(&gb); | |
6429 if(j != i){ | |
6430 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
6431 // return -1; | |
6432 } | |
6433 STOP_TIMER("get_ue_golomb"); | |
6434 } | |
6435 | |
6436 | |
1524 | 6437 init_put_bits(&pb, temp, SIZE); |
1168 | 6438 printf("testing signed exp golomb\n"); |
6439 for(i=0; i<COUNT; i++){ | |
6440 START_TIMER | |
6441 set_se_golomb(&pb, i - COUNT/2); | |
6442 STOP_TIMER("set_se_golomb"); | |
6443 } | |
6444 flush_put_bits(&pb); | |
6445 | |
6446 init_get_bits(&gb, temp, 8*SIZE); | |
6447 for(i=0; i<COUNT; i++){ | |
6448 int j, s; | |
6449 | |
6450 s= show_bits(&gb, 24); | |
6451 | |
6452 START_TIMER | |
6453 j= get_se_golomb(&gb); | |
6454 if(j != i - COUNT/2){ | |
6455 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
6456 // return -1; | |
6457 } | |
6458 STOP_TIMER("get_se_golomb"); | |
6459 } | |
6460 | |
6461 printf("testing 4x4 (I)DCT\n"); | |
6462 | |
6463 DCTELEM block[16]; | |
6464 uint8_t src[16], ref[16]; | |
6465 uint64_t error= 0, max_error=0; | |
6466 | |
6467 for(i=0; i<COUNT; i++){ | |
6468 int j; | |
6469 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
6470 for(j=0; j<16; j++){ | |
6471 ref[j]= random()%255; | |
6472 src[j]= random()%255; | |
6473 } | |
6474 | |
6475 h264_diff_dct_c(block, src, ref, 4); | |
6476 | |
6477 //normalize | |
6478 for(j=0; j<16; j++){ | |
6479 // printf("%d ", block[j]); | |
6480 block[j]= block[j]*4; | |
6481 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
6482 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
6483 } | |
6484 // printf("\n"); | |
6485 | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
6486 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 6487 /* for(j=0; j<16; j++){ |
6488 printf("%d ", ref[j]); | |
6489 } | |
6490 printf("\n");*/ | |
6491 | |
6492 for(j=0; j<16; j++){ | |
6493 int diff= ABS(src[j] - ref[j]); | |
6494 | |
6495 error+= diff*diff; | |
6496 max_error= FFMAX(max_error, diff); | |
6497 } | |
6498 } | |
6499 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
6500 #if 0 | |
6501 printf("testing quantizer\n"); | |
6502 for(qp=0; qp<52; qp++){ | |
6503 for(i=0; i<16; i++) | |
6504 src1_block[i]= src2_block[i]= random()%255; | |
6505 | |
6506 } | |
6507 #endif | |
6508 printf("Testing NAL layer\n"); | |
6509 | |
6510 uint8_t bitstream[COUNT]; | |
6511 uint8_t nal[COUNT*2]; | |
6512 H264Context h; | |
6513 memset(&h, 0, sizeof(H264Context)); | |
6514 | |
6515 for(i=0; i<COUNT; i++){ | |
6516 int zeros= i; | |
6517 int nal_length; | |
6518 int consumed; | |
6519 int out_length; | |
6520 uint8_t *out; | |
6521 int j; | |
6522 | |
6523 for(j=0; j<COUNT; j++){ | |
6524 bitstream[j]= (random() % 255) + 1; | |
6525 } | |
6526 | |
6527 for(j=0; j<zeros; j++){ | |
6528 int pos= random() % COUNT; | |
6529 while(bitstream[pos] == 0){ | |
6530 pos++; | |
6531 pos %= COUNT; | |
6532 } | |
6533 bitstream[pos]=0; | |
6534 } | |
6535 | |
6536 START_TIMER | |
6537 | |
6538 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); | |
6539 if(nal_length<0){ | |
6540 printf("encoding failed\n"); | |
6541 return -1; | |
6542 } | |
6543 | |
6544 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); | |
6545 | |
6546 STOP_TIMER("NAL") | |
6547 | |
6548 if(out_length != COUNT){ | |
6549 printf("incorrect length %d %d\n", out_length, COUNT); | |
6550 return -1; | |
6551 } | |
6552 | |
6553 if(consumed != nal_length){ | |
6554 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
6555 return -1; | |
6556 } | |
6557 | |
6558 if(memcmp(bitstream, out, COUNT)){ | |
6559 printf("missmatch\n"); | |
6560 return -1; | |
6561 } | |
6562 } | |
6563 | |
6564 printf("Testing RBSP\n"); | |
6565 | |
6566 | |
6567 return 0; | |
6568 } | |
6569 #endif | |
6570 | |
6571 | |
6572 static int decode_end(AVCodecContext *avctx) | |
6573 { | |
6574 H264Context *h = avctx->priv_data; | |
6575 MpegEncContext *s = &h->s; | |
6576 | |
6577 free_tables(h); //FIXME cleanup init stuff perhaps | |
6578 MPV_common_end(s); | |
6579 | |
6580 // memset(h, 0, sizeof(H264Context)); | |
6581 | |
6582 return 0; | |
6583 } | |
6584 | |
6585 | |
6586 AVCodec h264_decoder = { | |
6587 "h264", | |
6588 CODEC_TYPE_VIDEO, | |
6589 CODEC_ID_H264, | |
6590 sizeof(H264Context), | |
6591 decode_init, | |
6592 NULL, | |
6593 decode_end, | |
6594 decode_frame, | |
2453 | 6595 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1168 | 6596 }; |
6597 | |
1988 | 6598 AVCodecParser h264_parser = { |
6599 { CODEC_ID_H264 }, | |
2392 | 6600 sizeof(H264Context), |
1988 | 6601 NULL, |
6602 h264_parse, | |
6603 ff_parse_close, | |
6604 }; | |
6605 | |
1234 | 6606 #include "svq3.c" |