Mercurial > libavcodec.hg
annotate h264.c @ 2504:f12657081093 libavcodec
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
This patch adds the support for INTRA PCM macroblocks in CAVLC and CABAC
mode, the deblocking needed a small modification and so did the
intra4x4_pred_mode prediction.
With this patch, the 5 streams of the conformance suite containing INTRA
PCM macroblocks now decode entirely, 4 are completely corrects, 1 is
incorrect since the first B slice because of deblocking in B slice not
yet implemented.
The code is not optimized for speed, it is not necessary IPCM
macroblocks are rare, but it could be optimized for code size, if
someone want to do this, feel free.
author | michael |
---|---|
date | Mon, 07 Feb 2005 00:10:28 +0000 |
parents | 4d6d056a00c6 |
children | b3b06ba8787c |
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; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
485 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
486 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
487 else{ |
1168 | 488 pred= 2; |
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; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
501 if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
502 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
503 else{ |
1168 | 504 pred= 2; |
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 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2742 if (IS_INTRA_PCM(mb_type)) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2743 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2744 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2745 // The pixels are stored in h->mb array in the same order as levels, |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2746 // copy them in output in the correct order. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2747 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2748 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2749 for (x=0; x<4; x++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2750 *(dest_y + h->block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x]; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2751 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2752 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2753 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2754 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2755 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2756 for (x=0; x<4; x++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2757 *(dest_cb + h->block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x]; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2758 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2759 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2760 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2761 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2762 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2763 for (x=0; x<4; x++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2764 *(dest_cr + h->block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x]; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2765 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2766 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2767 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2768 goto deblock; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2769 } |
1168 | 2770 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
|
2771 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
|
2772 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
|
2773 |
1168 | 2774 if(!(s->flags&CODEC_FLAG_GRAY)){ |
2775 h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize); | |
2776 h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize); | |
2777 } | |
2778 | |
2779 if(IS_INTRA4x4(mb_type)){ | |
2780 if(!s->encoding){ | |
2781 for(i=0; i<16; i++){ | |
2782 uint8_t * const ptr= dest_y + h->block_offset[i]; | |
2383 | 2783 uint8_t *topright; |
1168 | 2784 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ]; |
2785 int tr; | |
2786 | |
2383 | 2787 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){ |
2788 const int topright_avail= (h->topright_samples_available<<i)&0x8000; | |
2789 assert(mb_y || linesize <= h->block_offset[i]); | |
2790 if(!topright_avail){ | |
2791 tr= ptr[3 - linesize]*0x01010101; | |
2792 topright= (uint8_t*) &tr; | |
2793 }else if(i==5 && h->deblocking_filter){ | |
2794 tr= *(uint32_t*)h->top_border[mb_x+1]; | |
2795 topright= (uint8_t*) &tr; | |
2796 }else | |
2797 topright= ptr + 4 - linesize; | |
2798 }else | |
2799 topright= NULL; | |
1168 | 2800 |
2801 h->pred4x4[ dir ](ptr, topright, linesize); | |
1234 | 2802 if(h->non_zero_count_cache[ scan8[i] ]){ |
2803 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
|
2804 s->dsp.h264_idct_add(ptr, h->mb + i*16, linesize); |
1234 | 2805 else |
2806 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0); | |
2807 } | |
1168 | 2808 } |
2809 } | |
2810 }else{ | |
2811 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); | |
1234 | 2812 if(s->codec_id == CODEC_ID_H264) |
2813 h264_luma_dc_dequant_idct_c(h->mb, s->qscale); | |
2814 else | |
2815 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale); | |
1168 | 2816 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2817 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
|
2818 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); |
1234 | 2819 }else if(s->codec_id == CODEC_ID_H264){ |
1168 | 2820 hl_motion(h, dest_y, dest_cb, dest_cr, |
2821 s->dsp.put_h264_qpel_pixels_tab, s->dsp.put_h264_chroma_pixels_tab, | |
2415 | 2822 s->dsp.avg_h264_qpel_pixels_tab, s->dsp.avg_h264_chroma_pixels_tab, |
2823 s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab); | |
1168 | 2824 } |
2825 | |
2826 | |
2827 if(!IS_INTRA4x4(mb_type)){ | |
1250 | 2828 if(s->codec_id == CODEC_ID_H264){ |
2829 for(i=0; i<16; i++){ | |
2830 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below | |
2831 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
|
2832 s->dsp.h264_idct_add(ptr, h->mb + i*16, linesize); |
1250 | 2833 } |
2834 } | |
2835 }else{ | |
2836 for(i=0; i<16; i++){ | |
2837 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below | |
2838 uint8_t * const ptr= dest_y + h->block_offset[i]; | |
1234 | 2839 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1250 | 2840 } |
1168 | 2841 } |
2842 } | |
2843 } | |
2844 | |
2845 if(!(s->flags&CODEC_FLAG_GRAY)){ | |
2846 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp); | |
2847 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp); | |
1250 | 2848 if(s->codec_id == CODEC_ID_H264){ |
2849 for(i=16; i<16+4; i++){ | |
2850 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2851 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
|
2852 s->dsp.h264_idct_add(ptr, h->mb + i*16, uvlinesize); |
1250 | 2853 } |
2854 } | |
2855 for(i=20; i<20+4; i++){ | |
2856 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2857 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
|
2858 s->dsp.h264_idct_add(ptr, h->mb + i*16, uvlinesize); |
1250 | 2859 } |
1168 | 2860 } |
1250 | 2861 }else{ |
2862 for(i=16; i<16+4; i++){ | |
2863 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2864 uint8_t * const ptr= dest_cb + h->block_offset[i]; | |
1234 | 2865 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2); |
1250 | 2866 } |
2867 } | |
2868 for(i=20; i<20+4; i++){ | |
2869 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ | |
2870 uint8_t * const ptr= dest_cr + h->block_offset[i]; | |
2871 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2); | |
2872 } | |
1168 | 2873 } |
2874 } | |
2875 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2876 deblock: |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2877 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
|
2878 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize); |
2449 | 2879 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
|
2880 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
|
2881 } |
1168 | 2882 } |
2883 | |
2884 /** | |
2885 * fills the default_ref_list. | |
2886 */ | |
2887 static int fill_default_ref_list(H264Context *h){ | |
2888 MpegEncContext * const s = &h->s; | |
2889 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
|
2890 int smallest_poc_greater_than_current = -1; |
1168 | 2891 Picture sorted_short_ref[16]; |
2892 | |
2893 if(h->slice_type==B_TYPE){ | |
2894 int out_i; | |
2895 int limit= -1; | |
2896 | |
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 /* sort frame according to poc in B slice */ |
1168 | 2898 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2899 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
|
2900 int best_poc=INT_MAX; |
1168 | 2901 |
2902 for(i=0; i<h->short_ref_count; i++){ | |
2903 const int poc= h->short_ref[i]->poc; | |
2904 if(poc > limit && poc < best_poc){ | |
2905 best_poc= poc; | |
2906 best_i= i; | |
2907 } | |
2908 } | |
2909 | |
2910 assert(best_i != -1); | |
2911 | |
2912 limit= best_poc; | |
2913 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
|
2914 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
|
2915 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
|
2916 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
|
2917 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
|
2918 } |
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
|
2919 } |
1168 | 2920 } |
2921 } | |
2922 | |
2923 if(s->picture_structure == PICT_FRAME){ | |
2924 if(h->slice_type==B_TYPE){ | |
2925 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
|
2926 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
|
2927 |
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
|
2928 // find the largest poc |
1168 | 2929 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
|
2930 int index = 0; |
2447 | 2931 int j= -99; |
2932 int step= list ? -1 : 1; | |
2933 | |
2934 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
2935 while(j<0 || j>= h->short_ref_count){ | |
2936 step = -step; | |
2937 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
|
2938 } |
2447 | 2939 if(sorted_short_ref[j].reference != 3) continue; |
2940 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
2941 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 2942 } |
2943 | |
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
|
2944 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
|
2945 if(h->long_ref[i] == NULL) continue; |
1168 | 2946 if(h->long_ref[i]->reference != 3) continue; |
2947 | |
2948 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
2949 h->default_ref_list[ list ][index++].pic_id= i;; | |
2950 } | |
2951 | |
2447 | 2952 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
|
2953 // 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
|
2954 // L0 and L1 are identical |
1168 | 2955 Picture temp= h->default_ref_list[1][0]; |
2956 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2957 h->default_ref_list[1][0] = temp; | |
2958 } | |
2959 | |
2960 if(index < h->ref_count[ list ]) | |
2961 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
2962 } | |
2963 }else{ | |
2964 int index=0; | |
2965 for(i=0; i<h->short_ref_count && index < h->ref_count[0]; i++){ | |
2966 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit | |
2967 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
2968 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
2969 } | |
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
|
2970 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
|
2971 if(h->long_ref[i] == NULL) continue; |
1168 | 2972 if(h->long_ref[i]->reference != 3) continue; |
2973 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
2974 h->default_ref_list[0][index++].pic_id= i;; | |
2975 } | |
2976 if(index < h->ref_count[0]) | |
2977 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
2978 } | |
2979 }else{ //FIELD | |
2980 if(h->slice_type==B_TYPE){ | |
2981 }else{ | |
2982 //FIXME second field balh | |
2983 } | |
2984 } | |
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
|
2985 #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
|
2986 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
|
2987 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
|
2988 } |
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
|
2989 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
|
2990 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
|
2991 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
|
2992 } |
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
|
2993 } |
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
|
2994 #endif |
1168 | 2995 return 0; |
2996 } | |
2997 | |
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
|
2998 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
|
2999 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
|
3000 |
1168 | 3001 static int decode_ref_pic_list_reordering(H264Context *h){ |
3002 MpegEncContext * const s = &h->s; | |
3003 int list; | |
3004 | |
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
|
3005 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
|
3006 print_long_term(h); |
1168 | 3007 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move beofre func |
3008 | |
3009 for(list=0; list<2; list++){ | |
3010 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); | |
3011 | |
3012 if(get_bits1(&s->gb)){ | |
3013 int pred= h->curr_pic_num; | |
3014 int index; | |
3015 | |
3016 for(index=0; ; index++){ | |
3017 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); | |
3018 int pic_id; | |
3019 int i; | |
3020 | |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3021 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
|
3022 break; |
1168 | 3023 |
3024 if(index >= h->ref_count[list]){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3025 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3026 return -1; |
3027 } | |
3028 | |
3029 if(reordering_of_pic_nums_idc<3){ | |
3030 if(reordering_of_pic_nums_idc<2){ | |
3031 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; | |
3032 | |
3033 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
|
3034 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3035 return -1; |
3036 } | |
3037 | |
3038 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3039 else pred+= abs_diff_pic_num; | |
3040 pred &= h->max_pic_num - 1; | |
3041 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3042 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
|
3043 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 | 3044 break; |
3045 } | |
3046 }else{ | |
3047 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
3048 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3049 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
|
3050 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 | 3051 break; |
3052 } | |
3053 } | |
3054 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3055 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3056 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3057 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
|
3058 } 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 | 3059 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
|
3060 if (i < index) { |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3061 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
|
3062 } |
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3063 for(; i > index; i--){ |
1168 | 3064 h->ref_list[list][i]= h->ref_list[list][i-1]; |
3065 } | |
3066 h->ref_list[list][index]= tmp; | |
3067 } | |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3068 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3069 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3070 return -1; |
3071 } | |
3072 } | |
3073 } | |
3074 | |
3075 if(h->slice_type!=B_TYPE) break; | |
3076 } | |
2396 | 3077 |
3078 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) | |
3079 direct_dist_scale_factor(h); | |
1168 | 3080 return 0; |
3081 } | |
3082 | |
3083 static int pred_weight_table(H264Context *h){ | |
3084 MpegEncContext * const s = &h->s; | |
3085 int list, i; | |
2415 | 3086 int luma_def, chroma_def; |
1168 | 3087 |
2415 | 3088 h->use_weight= 0; |
3089 h->use_weight_chroma= 0; | |
1168 | 3090 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
3091 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 3092 luma_def = 1<<h->luma_log2_weight_denom; |
3093 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 3094 |
3095 for(list=0; list<2; list++){ | |
3096 for(i=0; i<h->ref_count[list]; i++){ | |
3097 int luma_weight_flag, chroma_weight_flag; | |
3098 | |
3099 luma_weight_flag= get_bits1(&s->gb); | |
3100 if(luma_weight_flag){ | |
3101 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
3102 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 3103 if( h->luma_weight[list][i] != luma_def |
3104 || h->luma_offset[list][i] != 0) | |
3105 h->use_weight= 1; | |
3106 }else{ | |
3107 h->luma_weight[list][i]= luma_def; | |
3108 h->luma_offset[list][i]= 0; | |
1168 | 3109 } |
3110 | |
3111 chroma_weight_flag= get_bits1(&s->gb); | |
3112 if(chroma_weight_flag){ | |
3113 int j; | |
3114 for(j=0; j<2; j++){ | |
3115 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
3116 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 3117 if( h->chroma_weight[list][i][j] != chroma_def |
3118 || h->chroma_offset[list][i][j] != 0) | |
3119 h->use_weight_chroma= 1; | |
3120 } | |
3121 }else{ | |
3122 int j; | |
3123 for(j=0; j<2; j++){ | |
3124 h->chroma_weight[list][i][j]= chroma_def; | |
3125 h->chroma_offset[list][i][j]= 0; | |
1168 | 3126 } |
3127 } | |
3128 } | |
3129 if(h->slice_type != B_TYPE) break; | |
3130 } | |
2415 | 3131 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 3132 return 0; |
3133 } | |
3134 | |
2415 | 3135 static void implicit_weight_table(H264Context *h){ |
3136 MpegEncContext * const s = &h->s; | |
3137 int ref0, ref1; | |
3138 int cur_poc = s->current_picture_ptr->poc; | |
3139 | |
3140 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
3141 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
3142 h->use_weight= 0; | |
3143 h->use_weight_chroma= 0; | |
3144 return; | |
3145 } | |
3146 | |
3147 h->use_weight= 2; | |
3148 h->use_weight_chroma= 2; | |
3149 h->luma_log2_weight_denom= 5; | |
3150 h->chroma_log2_weight_denom= 5; | |
3151 | |
3152 /* FIXME: MBAFF */ | |
3153 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
3154 int poc0 = h->ref_list[0][ref0].poc; | |
3155 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
3156 int poc1 = h->ref_list[0][ref1].poc; | |
3157 int td = clip(poc1 - poc0, -128, 127); | |
3158 if(td){ | |
3159 int tb = clip(cur_poc - poc0, -128, 127); | |
3160 int tx = (16384 + (ABS(td) >> 1)) / td; | |
3161 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; | |
3162 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
3163 h->implicit_weight[ref0][ref1] = 32; | |
3164 else | |
3165 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
3166 }else | |
3167 h->implicit_weight[ref0][ref1] = 32; | |
3168 } | |
3169 } | |
3170 } | |
3171 | |
1168 | 3172 /** |
2392 | 3173 * instantaneous decoder refresh. |
1168 | 3174 */ |
3175 static void idr(H264Context *h){ | |
2409 | 3176 int i,j; |
3177 | |
3178 #define CHECK_DELAY(pic) \ | |
3179 for(j = 0; h->delayed_pic[j]; j++) \ | |
3180 if(pic == h->delayed_pic[j]){ \ | |
3181 pic->reference=1; \ | |
3182 break; \ | |
3183 } | |
1168 | 3184 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3185 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3186 if (h->long_ref[i] != NULL) { |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3187 h->long_ref[i]->reference=0; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3188 CHECK_DELAY(h->long_ref[i]); |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3189 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3190 } |
1168 | 3191 } |
3192 h->long_ref_count=0; | |
3193 | |
3194 for(i=0; i<h->short_ref_count; i++){ | |
3195 h->short_ref[i]->reference=0; | |
2409 | 3196 CHECK_DELAY(h->short_ref[i]); |
1168 | 3197 h->short_ref[i]= NULL; |
3198 } | |
3199 h->short_ref_count=0; | |
3200 } | |
2409 | 3201 #undef CHECK_DELAY |
1168 | 3202 |
3203 /** | |
3204 * | |
3205 * @return the removed picture or NULL if an error occures | |
3206 */ | |
3207 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 3208 MpegEncContext * const s = &h->s; |
1168 | 3209 int i; |
3210 | |
1169 | 3211 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
|
3212 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
1169 | 3213 |
1168 | 3214 for(i=0; i<h->short_ref_count; i++){ |
3215 Picture *pic= h->short_ref[i]; | |
1169 | 3216 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
|
3217 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 3218 if(pic->frame_num == frame_num){ |
3219 h->short_ref[i]= NULL; | |
3220 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
3221 h->short_ref_count--; | |
3222 return pic; | |
3223 } | |
3224 } | |
3225 return NULL; | |
3226 } | |
3227 | |
3228 /** | |
3229 * | |
3230 * @return the removed picture or NULL if an error occures | |
3231 */ | |
3232 static Picture * remove_long(H264Context *h, int i){ | |
3233 Picture *pic; | |
3234 | |
3235 pic= h->long_ref[i]; | |
3236 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
|
3237 if(pic) h->long_ref_count--; |
1168 | 3238 |
3239 return pic; | |
3240 } | |
3241 | |
3242 /** | |
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
|
3243 * 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
|
3244 */ |
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
|
3245 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
|
3246 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
|
3247 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
|
3248 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
|
3249 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
|
3250 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
|
3251 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
|
3252 } |
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
|
3253 } |
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
|
3254 } |
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
|
3255 |
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
|
3256 /** |
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
|
3257 * 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
|
3258 */ |
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
|
3259 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
|
3260 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
|
3261 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
|
3262 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
|
3263 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
|
3264 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
|
3265 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
|
3266 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
|
3267 } |
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
|
3268 } |
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
|
3269 } |
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
|
3270 } |
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
|
3271 |
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
|
3272 /** |
1168 | 3273 * Executes the reference picture marking (memory management control operations). |
3274 */ | |
3275 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
3276 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
|
3277 int i, j; |
1168 | 3278 int current_is_long=0; |
3279 Picture *pic; | |
3280 | |
3281 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
|
3282 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
1168 | 3283 |
3284 for(i=0; i<mmco_count; i++){ | |
3285 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
|
3286 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 | 3287 |
3288 switch(mmco[i].opcode){ | |
3289 case MMCO_SHORT2UNUSED: | |
3290 pic= remove_short(h, mmco[i].short_frame_num); | |
3291 if(pic==NULL) return -1; | |
3292 pic->reference= 0; | |
3293 break; | |
3294 case MMCO_SHORT2LONG: | |
3295 pic= remove_long(h, mmco[i].long_index); | |
3296 if(pic) pic->reference=0; | |
3297 | |
3298 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); | |
3299 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
|
3300 h->long_ref_count++; |
1168 | 3301 break; |
3302 case MMCO_LONG2UNUSED: | |
3303 pic= remove_long(h, mmco[i].long_index); | |
3304 if(pic==NULL) return -1; | |
3305 pic->reference= 0; | |
3306 break; | |
3307 case MMCO_LONG: | |
3308 pic= remove_long(h, mmco[i].long_index); | |
3309 if(pic) pic->reference=0; | |
3310 | |
3311 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; | |
3312 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
3313 h->long_ref_count++; | |
3314 | |
3315 current_is_long=1; | |
3316 break; | |
3317 case MMCO_SET_MAX_LONG: | |
3318 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
|
3319 // 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
|
3320 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
|
3321 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
|
3322 if (pic) pic->reference=0; |
1168 | 3323 } |
3324 break; | |
3325 case MMCO_RESET: | |
3326 while(h->short_ref_count){ | |
3327 pic= remove_short(h, h->short_ref[0]->frame_num); | |
3328 pic->reference=0; | |
3329 } | |
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
|
3330 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
|
3331 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
|
3332 if(pic) pic->reference=0; |
1168 | 3333 } |
3334 break; | |
3335 default: assert(0); | |
3336 } | |
3337 } | |
3338 | |
3339 if(!current_is_long){ | |
3340 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
3341 if(pic){ | |
3342 pic->reference=0; | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3343 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 3344 } |
3345 | |
3346 if(h->short_ref_count) | |
1169 | 3347 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
3348 | |
3349 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 3350 h->short_ref[0]->long_ref=0; |
3351 h->short_ref_count++; | |
3352 } | |
3353 | |
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
|
3354 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
|
3355 print_long_term(h); |
1168 | 3356 return 0; |
3357 } | |
3358 | |
3359 static int decode_ref_pic_marking(H264Context *h){ | |
3360 MpegEncContext * const s = &h->s; | |
3361 int i; | |
3362 | |
3363 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields | |
3364 s->broken_link= get_bits1(&s->gb) -1; | |
3365 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
3366 if(h->mmco[0].long_index == -1) | |
3367 h->mmco_index= 0; | |
3368 else{ | |
3369 h->mmco[0].opcode= MMCO_LONG; | |
3370 h->mmco_index= 1; | |
3371 } | |
3372 }else{ | |
3373 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
|
3374 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 3375 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
3376 | |
3377 h->mmco[i].opcode= opcode; | |
3378 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
3379 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 | |
3380 /* if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){ | |
3381 fprintf(stderr, "illegal short ref in memory management control operation %d\n", mmco); | |
3382 return -1; | |
3383 }*/ | |
3384 } | |
3385 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
3386 h->mmco[i].long_index= get_ue_golomb(&s->gb); | |
3387 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
|
3388 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 3389 return -1; |
3390 } | |
3391 } | |
3392 | |
3393 if(opcode > MMCO_LONG){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3394 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 3395 return -1; |
3396 } | |
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
|
3397 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
|
3398 break; |
1168 | 3399 } |
3400 h->mmco_index= i; | |
3401 }else{ | |
3402 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
3403 | |
3404 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
3405 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
3406 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
3407 h->mmco_index= 1; | |
3408 }else | |
3409 h->mmco_index= 0; | |
3410 } | |
3411 } | |
3412 | |
3413 return 0; | |
3414 } | |
3415 | |
3416 static int init_poc(H264Context *h){ | |
3417 MpegEncContext * const s = &h->s; | |
3418 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
3419 int field_poc[2]; | |
3420 | |
3421 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
3422 h->frame_num_offset= 0; | |
3423 }else{ | |
3424 if(h->frame_num < h->prev_frame_num) | |
3425 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
3426 else | |
3427 h->frame_num_offset= h->prev_frame_num_offset; | |
3428 } | |
3429 | |
3430 if(h->sps.poc_type==0){ | |
3431 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
3432 | |
3433 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) | |
3434 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
3435 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
3436 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
3437 else | |
3438 h->poc_msb = h->prev_poc_msb; | |
3439 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
3440 field_poc[0] = | |
3441 field_poc[1] = h->poc_msb + h->poc_lsb; | |
3442 if(s->picture_structure == PICT_FRAME) | |
3443 field_poc[1] += h->delta_poc_bottom; | |
3444 }else if(h->sps.poc_type==1){ | |
3445 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
3446 int i; | |
3447 | |
3448 if(h->sps.poc_cycle_length != 0) | |
3449 abs_frame_num = h->frame_num_offset + h->frame_num; | |
3450 else | |
3451 abs_frame_num = 0; | |
3452 | |
3453 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
3454 abs_frame_num--; | |
3455 | |
3456 expected_delta_per_poc_cycle = 0; | |
3457 for(i=0; i < h->sps.poc_cycle_length; i++) | |
3458 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
3459 | |
3460 if(abs_frame_num > 0){ | |
3461 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
3462 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
3463 | |
3464 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
3465 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
3466 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
3467 } else | |
3468 expectedpoc = 0; | |
3469 | |
3470 if(h->nal_ref_idc == 0) | |
3471 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; | |
3472 | |
3473 field_poc[0] = expectedpoc + h->delta_poc[0]; | |
3474 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
3475 | |
3476 if(s->picture_structure == PICT_FRAME) | |
3477 field_poc[1] += h->delta_poc[1]; | |
3478 }else{ | |
3479 int poc; | |
3480 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
3481 poc= 0; | |
3482 }else{ | |
3483 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
3484 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
3485 } | |
3486 field_poc[0]= poc; | |
3487 field_poc[1]= poc; | |
3488 } | |
3489 | |
3490 if(s->picture_structure != PICT_BOTTOM_FIELD) | |
3491 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
3492 if(s->picture_structure != PICT_TOP_FIELD) | |
3493 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
3494 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
3495 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
3496 | |
3497 return 0; | |
3498 } | |
3499 | |
3500 /** | |
3501 * decodes a slice header. | |
3502 * this will allso call MPV_common_init() and frame_start() as needed | |
3503 */ | |
3504 static int decode_slice_header(H264Context *h){ | |
3505 MpegEncContext * const s = &h->s; | |
3506 int first_mb_in_slice, pps_id; | |
3507 int num_ref_idx_active_override_flag; | |
3508 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3509 int slice_type; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3510 int default_ref_list_done = 0; |
1168 | 3511 |
3512 s->current_picture.reference= h->nal_ref_idc != 0; | |
3513 | |
3514 first_mb_in_slice= get_ue_golomb(&s->gb); | |
3515 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3516 slice_type= get_ue_golomb(&s->gb); |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3517 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3518 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 | 3519 return -1; |
1168 | 3520 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3521 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3522 slice_type -= 5; |
1168 | 3523 h->slice_type_fixed=1; |
3524 }else | |
3525 h->slice_type_fixed=0; | |
3526 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3527 slice_type= slice_type_map[ slice_type ]; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3528 if (slice_type == I_TYPE |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3529 || (h->slice_num != 0 && slice_type == h->slice_type) ) { |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3530 default_ref_list_done = 1; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3531 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3532 h->slice_type= slice_type; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3533 |
1168 | 3534 s->pict_type= h->slice_type; // to make a few old func happy, its wrong though |
3535 | |
3536 pps_id= get_ue_golomb(&s->gb); | |
3537 if(pps_id>255){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3538 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 3539 return -1; |
3540 } | |
3541 h->pps= h->pps_buffer[pps_id]; | |
1174 | 3542 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
|
3543 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 3544 return -1; |
3545 } | |
3546 | |
1168 | 3547 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 3548 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
|
3549 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 3550 return -1; |
3551 } | |
1168 | 3552 |
3553 s->mb_width= h->sps.mb_width; | |
3554 s->mb_height= h->sps.mb_height; | |
3555 | |
2395 | 3556 h->b_stride= s->mb_width*4 + 1; |
3557 h->b8_stride= s->mb_width*2 + 1; | |
1168 | 3558 |
2392 | 3559 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3560 s->resync_mb_y = s->mb_y = first_mb_in_slice / s->mb_width; //FIXME AFFW | |
1168 | 3561 |
1371 | 3562 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 3563 if(h->sps.frame_mbs_only_flag) |
1371 | 3564 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 3565 else |
1371 | 3566 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
1168 | 3567 |
3568 if (s->context_initialized | |
1548 | 3569 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 3570 free_tables(h); |
3571 MPV_common_end(s); | |
3572 } | |
3573 if (!s->context_initialized) { | |
3574 if (MPV_common_init(s) < 0) | |
3575 return -1; | |
3576 | |
3577 alloc_tables(h); | |
3578 | |
3579 s->avctx->width = s->width; | |
3580 s->avctx->height = s->height; | |
1548 | 3581 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 3582 if(!s->avctx->sample_aspect_ratio.den) |
3583 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
|
3584 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3585 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
|
3586 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
|
3587 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
|
3588 } |
1168 | 3589 } |
3590 | |
2392 | 3591 if(h->slice_num == 0){ |
1168 | 3592 frame_start(h); |
3593 } | |
3594 | |
1169 | 3595 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 3596 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
3597 | |
3598 if(h->sps.frame_mbs_only_flag){ | |
3599 s->picture_structure= PICT_FRAME; | |
3600 }else{ | |
3601 if(get_bits1(&s->gb)) //field_pic_flag | |
3602 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag | |
3603 else | |
3604 s->picture_structure= PICT_FRAME; | |
3605 } | |
3606 | |
3607 if(s->picture_structure==PICT_FRAME){ | |
3608 h->curr_pic_num= h->frame_num; | |
3609 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
3610 }else{ | |
3611 h->curr_pic_num= 2*h->frame_num; | |
3612 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
3613 } | |
3614 | |
3615 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
1453 | 3616 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 3617 } |
3618 | |
3619 if(h->sps.poc_type==0){ | |
3620 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
3621 | |
3622 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ | |
3623 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
3624 } | |
3625 } | |
3626 | |
3627 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ | |
3628 h->delta_poc[0]= get_se_golomb(&s->gb); | |
3629 | |
3630 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) | |
3631 h->delta_poc[1]= get_se_golomb(&s->gb); | |
3632 } | |
3633 | |
3634 init_poc(h); | |
3635 | |
3636 if(h->pps.redundant_pic_cnt_present){ | |
3637 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
3638 } | |
3639 | |
3640 //set defaults, might be overriden a few line later | |
3641 h->ref_count[0]= h->pps.ref_count[0]; | |
3642 h->ref_count[1]= h->pps.ref_count[1]; | |
3643 | |
3644 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
3645 if(h->slice_type == B_TYPE){ | |
3646 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3647 } | |
3648 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
3649 | |
3650 if(num_ref_idx_active_override_flag){ | |
3651 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
3652 if(h->slice_type==B_TYPE) | |
3653 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
3654 | |
3655 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
|
3656 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
1168 | 3657 return -1; |
3658 } | |
3659 } | |
3660 } | |
3661 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3662 if(!default_ref_list_done){ |
1168 | 3663 fill_default_ref_list(h); |
3664 } | |
3665 | |
3666 decode_ref_pic_list_reordering(h); | |
3667 | |
3668 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) | |
3669 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) | |
3670 pred_weight_table(h); | |
2415 | 3671 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
3672 implicit_weight_table(h); | |
3673 else | |
3674 h->use_weight = 0; | |
1168 | 3675 |
3676 if(s->current_picture.reference) | |
3677 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
|
3678 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3679 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
|
3680 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
|
3681 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3682 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
|
3683 s->qscale = h->pps.init_qp + get_se_golomb(&s->gb); |
1898 | 3684 if(s->qscale<0 || s->qscale>51){ |
3685 av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale); | |
3686 return -1; | |
3687 } | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
3688 h->chroma_qp = get_chroma_qp(h, s->qscale); |
1168 | 3689 //FIXME qscale / qp ... stuff |
3690 if(h->slice_type == SP_TYPE){ | |
1453 | 3691 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 3692 } |
3693 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 3694 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 3695 } |
3696 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3697 h->deblocking_filter = 1; |
1898 | 3698 h->slice_alpha_c0_offset = 0; |
3699 h->slice_beta_offset = 0; | |
1168 | 3700 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
|
3701 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
|
3702 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
|
3703 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
|
3704 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3705 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
|
3706 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
|
3707 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 3708 } |
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
|
3709 } |
1168 | 3710 |
3711 #if 0 //FMO | |
3712 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
3713 slice_group_change_cycle= get_bits(&s->gb, ?); | |
3714 #endif | |
3715 | |
2392 | 3716 h->slice_num++; |
3717 | |
1168 | 3718 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2415 | 3719 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 | 3720 h->slice_num, first_mb_in_slice, |
1264 | 3721 av_get_pict_type_char(h->slice_type), |
1168 | 3722 pps_id, h->frame_num, |
3723 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
3724 h->ref_count[0], h->ref_count[1], | |
3725 s->qscale, | |
2415 | 3726 h->deblocking_filter, |
3727 h->use_weight, | |
3728 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 3729 ); |
3730 } | |
3731 | |
3732 return 0; | |
3733 } | |
3734 | |
3735 /** | |
3736 * | |
3737 */ | |
3738 static inline int get_level_prefix(GetBitContext *gb){ | |
3739 unsigned int buf; | |
3740 int log; | |
3741 | |
3742 OPEN_READER(re, gb); | |
3743 UPDATE_CACHE(re, gb); | |
3744 buf=GET_CACHE(re, gb); | |
3745 | |
3746 log= 32 - av_log2(buf); | |
3747 #ifdef TRACE | |
3748 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
|
3749 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 | 3750 #endif |
3751 | |
3752 LAST_SKIP_BITS(re, gb, log); | |
3753 CLOSE_READER(re, gb); | |
3754 | |
3755 return log-1; | |
3756 } | |
3757 | |
3758 /** | |
3759 * decodes a residual block. | |
3760 * @param n block index | |
3761 * @param scantable scantable | |
3762 * @param max_coeff number of coefficients in the block | |
3763 * @return <0 if an error occured | |
3764 */ | |
3765 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, int qp, int max_coeff){ | |
3766 MpegEncContext * const s = &h->s; | |
3767 const uint16_t *qmul= dequant_coeff[qp]; | |
3768 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}; | |
3769 int level[16], run[16]; | |
3770 int suffix_length, zeros_left, coeff_num, coeff_token, total_coeff, i, trailing_ones; | |
3771 | |
3772 //FIXME put trailing_onex into the context | |
3773 | |
3774 if(n == CHROMA_DC_BLOCK_INDEX){ | |
3775 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
3776 total_coeff= coeff_token>>2; | |
3777 }else{ | |
3778 if(n == LUMA_DC_BLOCK_INDEX){ | |
3779 total_coeff= pred_non_zero_count(h, 0); | |
3780 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
3781 total_coeff= coeff_token>>2; | |
3782 }else{ | |
3783 total_coeff= pred_non_zero_count(h, n); | |
3784 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
3785 total_coeff= coeff_token>>2; | |
3786 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
3787 } | |
3788 } | |
3789 | |
3790 //FIXME set last_non_zero? | |
3791 | |
3792 if(total_coeff==0) | |
3793 return 0; | |
3794 | |
3795 trailing_ones= coeff_token&3; | |
1170 | 3796 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 3797 assert(total_coeff<=16); |
3798 | |
3799 for(i=0; i<trailing_ones; i++){ | |
3800 level[i]= 1 - 2*get_bits1(gb); | |
3801 } | |
3802 | |
3803 suffix_length= total_coeff > 10 && trailing_ones < 3; | |
3804 | |
3805 for(; i<total_coeff; i++){ | |
3806 const int prefix= get_level_prefix(gb); | |
3807 int level_code, mask; | |
3808 | |
3809 if(prefix<14){ //FIXME try to build a large unified VLC table for all this | |
3810 if(suffix_length) | |
3811 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
3812 else | |
3813 level_code= (prefix<<suffix_length); //part | |
3814 }else if(prefix==14){ | |
3815 if(suffix_length) | |
3816 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
3817 else | |
3818 level_code= prefix + get_bits(gb, 4); //part | |
3819 }else if(prefix==15){ | |
3820 level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part | |
3821 if(suffix_length==0) level_code+=15; //FIXME doesnt make (much)sense | |
3822 }else{ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3823 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 3824 return -1; |
3825 } | |
3826 | |
3827 if(i==trailing_ones && i<3) level_code+= 2; //FIXME split first iteration | |
3828 | |
3829 mask= -(level_code&1); | |
3830 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
3831 | |
3832 if(suffix_length==0) suffix_length=1; //FIXME split first iteration | |
3833 | |
3834 #if 1 | |
3835 if(ABS(level[i]) > (3<<(suffix_length-1)) && suffix_length<6) suffix_length++; | |
3836 #else | |
3837 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
|
3838 /* ? == prefix > 2 or sth */ |
1168 | 3839 #endif |
1170 | 3840 tprintf("level: %d suffix_length:%d\n", level[i], suffix_length); |
1168 | 3841 } |
3842 | |
3843 if(total_coeff == max_coeff) | |
3844 zeros_left=0; | |
3845 else{ | |
3846 if(n == CHROMA_DC_BLOCK_INDEX) | |
3847 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
3848 else | |
3849 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
3850 } | |
3851 | |
3852 for(i=0; i<total_coeff-1; i++){ | |
3853 if(zeros_left <=0) | |
3854 break; | |
3855 else if(zeros_left < 7){ | |
3856 run[i]= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
3857 }else{ | |
3858 run[i]= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
3859 } | |
3860 zeros_left -= run[i]; | |
3861 } | |
3862 | |
3863 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3864 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 3865 return -1; |
3866 } | |
3867 | |
3868 for(; i<total_coeff-1; i++){ | |
3869 run[i]= 0; | |
3870 } | |
3871 | |
3872 run[i]= zeros_left; | |
3873 | |
3874 coeff_num=-1; | |
3875 if(n > 24){ | |
3876 for(i=total_coeff-1; i>=0; i--){ //FIXME merge into rundecode? | |
3877 int j; | |
3878 | |
3879 coeff_num += run[i] + 1; //FIXME add 1 earlier ? | |
3880 j= scantable[ coeff_num ]; | |
3881 | |
3882 block[j]= level[i]; | |
3883 } | |
3884 }else{ | |
3885 for(i=total_coeff-1; i>=0; i--){ //FIXME merge into rundecode? | |
3886 int j; | |
3887 | |
3888 coeff_num += run[i] + 1; //FIXME add 1 earlier ? | |
3889 j= scantable[ coeff_num ]; | |
3890 | |
3891 block[j]= level[i] * qmul[j]; | |
3892 // printf("%d %d ", block[j], qmul[j]); | |
3893 } | |
3894 } | |
3895 return 0; | |
3896 } | |
3897 | |
3898 /** | |
2396 | 3899 * decodes a P_SKIP or B_SKIP macroblock |
3900 */ | |
3901 static void decode_mb_skip(H264Context *h){ | |
3902 MpegEncContext * const s = &h->s; | |
3903 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
3904 int mb_type; | |
3905 | |
3906 memset(h->non_zero_count[mb_xy], 0, 16); | |
3907 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
3908 | |
3909 if( h->slice_type == B_TYPE ) | |
3910 { | |
3911 // just for fill_caches. pred_direct_motion will set the real mb_type | |
3912 mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; | |
3913 //FIXME mbaff | |
3914 | |
2449 | 3915 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 3916 pred_direct_motion(h, &mb_type); |
3917 if(h->pps.cabac){ | |
3918 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
3919 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
3920 } | |
3921 } | |
3922 else | |
3923 { | |
3924 int mx, my; | |
3925 mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; | |
3926 | |
3927 if(h->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){ | |
3928 h->mb_field_decoding_flag= get_bits1(&s->gb); | |
3929 } | |
3930 if(h->mb_field_decoding_flag) | |
3931 mb_type|= MB_TYPE_INTERLACED; | |
3932 | |
2449 | 3933 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 3934 pred_pskip_motion(h, &mx, &my); |
3935 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
3936 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
3937 if(h->pps.cabac) | |
3938 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
3939 } | |
3940 | |
3941 write_back_motion(h, mb_type); | |
3942 s->current_picture.mb_type[mb_xy]= mb_type|MB_TYPE_SKIP; | |
3943 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
3944 h->slice_table[ mb_xy ]= h->slice_num; | |
3945 h->prev_mb_skiped= 1; | |
3946 } | |
3947 | |
3948 /** | |
1168 | 3949 * decodes a macroblock |
3950 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
3951 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3952 static int decode_mb_cavlc(H264Context *h){ |
1168 | 3953 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
|
3954 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1169 | 3955 int mb_type, partition_count, cbp; |
1168 | 3956 |
1252 | 3957 s->dsp.clear_blocks(h->mb); //FIXME avoid if allready clear (move after skip handlong? |
1168 | 3958 |
1170 | 3959 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 3960 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
3961 down the code */ | |
1168 | 3962 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
3963 if(s->mb_skip_run==-1) | |
3964 s->mb_skip_run= get_ue_golomb(&s->gb); | |
3965 | |
3966 if (s->mb_skip_run--) { | |
2396 | 3967 decode_mb_skip(h); |
1168 | 3968 return 0; |
3969 } | |
3970 } | |
3971 if(h->sps.mb_aff /* && !field pic FIXME needed? */){ | |
3972 if((s->mb_y&1)==0) | |
3973 h->mb_field_decoding_flag = get_bits1(&s->gb); | |
3974 }else | |
3975 h->mb_field_decoding_flag=0; //FIXME som ed note ?! | |
3976 | |
3977 h->prev_mb_skiped= 0; | |
3978 | |
3979 mb_type= get_ue_golomb(&s->gb); | |
3980 if(h->slice_type == B_TYPE){ | |
3981 if(mb_type < 23){ | |
3982 partition_count= b_mb_type_info[mb_type].partition_count; | |
3983 mb_type= b_mb_type_info[mb_type].type; | |
3984 }else{ | |
3985 mb_type -= 23; | |
3986 goto decode_intra_mb; | |
3987 } | |
3988 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
3989 if(mb_type < 5){ | |
3990 partition_count= p_mb_type_info[mb_type].partition_count; | |
3991 mb_type= p_mb_type_info[mb_type].type; | |
3992 }else{ | |
3993 mb_type -= 5; | |
3994 goto decode_intra_mb; | |
3995 } | |
3996 }else{ | |
3997 assert(h->slice_type == I_TYPE); | |
3998 decode_intra_mb: | |
3999 if(mb_type > 25){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4000 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 | 4001 return -1; |
4002 } | |
4003 partition_count=0; | |
4004 cbp= i_mb_type_info[mb_type].cbp; | |
4005 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
4006 mb_type= i_mb_type_info[mb_type].type; | |
4007 } | |
4008 | |
4009 if(h->mb_field_decoding_flag) | |
4010 mb_type |= MB_TYPE_INTERLACED; | |
4011 | |
4012 s->current_picture.mb_type[mb_xy]= mb_type; | |
4013 h->slice_table[ mb_xy ]= h->slice_num; | |
4014 | |
4015 if(IS_INTRA_PCM(mb_type)){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4016 unsigned int x, y; |
1168 | 4017 |
4018 // we assume these blocks are very rare so we dont optimize it | |
4019 align_get_bits(&s->gb); | |
4020 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4021 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 4022 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4023 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 4024 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4025 tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4026 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 4027 } |
4028 } | |
4029 for(y=0; y<8; y++){ | |
4030 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
4031 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4032 tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4033 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 4034 } |
4035 } | |
4036 for(y=0; y<8; y++){ | |
4037 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
4038 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4039 tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4040 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 4041 } |
4042 } | |
4043 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4044 // In deblocking, the quantiser is 0 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4045 s->current_picture.qscale_table[mb_xy]= 0; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4046 h->chroma_qp = get_chroma_qp(h, 0); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4047 // All coeffs are presents |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4048 memset(h->non_zero_count[mb_xy], 16, 16); |
1168 | 4049 |
4050 return 0; | |
4051 } | |
4052 | |
2449 | 4053 fill_caches(h, mb_type, 0); |
1168 | 4054 |
4055 //mb_pred | |
4056 if(IS_INTRA(mb_type)){ | |
4057 // init_top_left_availability(h); | |
4058 if(IS_INTRA4x4(mb_type)){ | |
4059 int i; | |
4060 | |
4061 // fill_intra4x4_pred_table(h); | |
4062 for(i=0; i<16; i++){ | |
4063 const int mode_coded= !get_bits1(&s->gb); | |
4064 const int predicted_mode= pred_intra_mode(h, i); | |
4065 int mode; | |
4066 | |
4067 if(mode_coded){ | |
4068 const int rem_mode= get_bits(&s->gb, 3); | |
4069 if(rem_mode<predicted_mode) | |
4070 mode= rem_mode; | |
4071 else | |
4072 mode= rem_mode + 1; | |
4073 }else{ | |
4074 mode= predicted_mode; | |
4075 } | |
4076 | |
4077 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
4078 } | |
4079 write_back_intra_pred_mode(h); | |
4080 if( check_intra4x4_pred_mode(h) < 0) | |
4081 return -1; | |
4082 }else{ | |
4083 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
4084 if(h->intra16x16_pred_mode < 0) | |
4085 return -1; | |
4086 } | |
4087 h->chroma_pred_mode= get_ue_golomb(&s->gb); | |
4088 | |
4089 h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode); | |
4090 if(h->chroma_pred_mode < 0) | |
4091 return -1; | |
4092 }else if(partition_count==4){ | |
4093 int i, j, sub_partition_count[4], list, ref[2][4]; | |
4094 | |
4095 if(h->slice_type == B_TYPE){ | |
4096 for(i=0; i<4; i++){ | |
4097 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4098 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
|
4099 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 | 4100 return -1; |
4101 } | |
4102 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4103 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4104 } | |
2396 | 4105 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
4106 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) | |
4107 pred_direct_motion(h, &mb_type); | |
1168 | 4108 }else{ |
4109 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
4110 for(i=0; i<4; i++){ | |
4111 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4112 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
|
4113 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 | 4114 return -1; |
4115 } | |
4116 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4117 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4118 } | |
4119 } | |
4120 | |
4121 for(list=0; list<2; list++){ | |
4122 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
4123 if(ref_count == 0) continue; | |
4124 for(i=0; i<4; i++){ | |
2396 | 4125 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
4126 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1168 | 4127 ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
4128 }else{ | |
4129 //FIXME | |
4130 ref[list][i] = -1; | |
4131 } | |
4132 } | |
4133 } | |
4134 | |
4135 for(list=0; list<2; list++){ | |
4136 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
4137 if(ref_count == 0) continue; | |
4138 | |
4139 for(i=0; i<4; i++){ | |
2396 | 4140 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
1168 | 4141 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
4142 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
4143 | |
2396 | 4144 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 4145 const int sub_mb_type= h->sub_mb_type[i]; |
4146 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
4147 for(j=0; j<sub_partition_count[i]; j++){ | |
4148 int mx, my; | |
4149 const int index= 4*i + block_width*j; | |
4150 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
4151 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
4152 mx += get_se_golomb(&s->gb); | |
4153 my += get_se_golomb(&s->gb); | |
1170 | 4154 tprintf("final mv:%d %d\n", mx, my); |
4155 | |
1168 | 4156 if(IS_SUB_8X8(sub_mb_type)){ |
4157 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= | |
4158 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
4159 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= | |
4160 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
4161 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4162 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; | |
4163 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; | |
4164 }else if(IS_SUB_4X8(sub_mb_type)){ | |
4165 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; | |
4166 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; | |
4167 }else{ | |
4168 assert(IS_SUB_4X4(sub_mb_type)); | |
4169 mv_cache[ 0 ][0]= mx; | |
4170 mv_cache[ 0 ][1]= my; | |
4171 } | |
4172 } | |
4173 }else{ | |
4174 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
4175 p[0] = p[1]= | |
4176 p[8] = p[9]= 0; | |
4177 } | |
4178 } | |
4179 } | |
2396 | 4180 }else if(IS_DIRECT(mb_type)){ |
4181 pred_direct_motion(h, &mb_type); | |
4182 s->current_picture.mb_type[mb_xy]= mb_type; | |
4183 }else{ | |
1168 | 4184 int list, mx, my, i; |
4185 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
4186 if(IS_16X16(mb_type)){ | |
4187 for(list=0; list<2; list++){ | |
2392 | 4188 if(h->ref_count[list]>0){ |
1168 | 4189 if(IS_DIR(mb_type, 0, list)){ |
4190 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
4191 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
4192 } | |
4193 } | |
4194 } | |
4195 for(list=0; list<2; list++){ | |
4196 if(IS_DIR(mb_type, 0, list)){ | |
4197 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
4198 mx += get_se_golomb(&s->gb); | |
4199 my += get_se_golomb(&s->gb); | |
1170 | 4200 tprintf("final mv:%d %d\n", mx, my); |
4201 | |
1269 | 4202 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
1168 | 4203 } |
4204 } | |
4205 } | |
4206 else if(IS_16X8(mb_type)){ | |
4207 for(list=0; list<2; list++){ | |
4208 if(h->ref_count[list]>0){ | |
4209 for(i=0; i<2; i++){ | |
4210 if(IS_DIR(mb_type, i, list)){ | |
4211 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
4212 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
2396 | 4213 }else // needed only for mixed refs (e.g. B_L0_L1_16x8) |
4214 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 4215 } |
4216 } | |
4217 } | |
4218 for(list=0; list<2; list++){ | |
4219 for(i=0; i<2; i++){ | |
4220 if(IS_DIR(mb_type, i, list)){ | |
4221 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
4222 mx += get_se_golomb(&s->gb); | |
4223 my += get_se_golomb(&s->gb); | |
1170 | 4224 tprintf("final mv:%d %d\n", mx, my); |
4225 | |
1269 | 4226 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 4227 }else |
4228 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 4229 } |
4230 } | |
4231 }else{ | |
4232 assert(IS_8X16(mb_type)); | |
4233 for(list=0; list<2; list++){ | |
4234 if(h->ref_count[list]>0){ | |
4235 for(i=0; i<2; i++){ | |
4236 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
4237 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
4238 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
2396 | 4239 }else // needed only for mixed refs |
4240 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 4241 } |
4242 } | |
4243 } | |
4244 for(list=0; list<2; list++){ | |
4245 for(i=0; i<2; i++){ | |
4246 if(IS_DIR(mb_type, i, list)){ | |
4247 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
4248 mx += get_se_golomb(&s->gb); | |
4249 my += get_se_golomb(&s->gb); | |
1170 | 4250 tprintf("final mv:%d %d\n", mx, my); |
4251 | |
1269 | 4252 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 4253 }else |
4254 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 4255 } |
4256 } | |
4257 } | |
4258 } | |
4259 | |
4260 if(IS_INTER(mb_type)) | |
4261 write_back_motion(h, mb_type); | |
4262 | |
4263 if(!IS_INTRA16x16(mb_type)){ | |
4264 cbp= get_ue_golomb(&s->gb); | |
4265 if(cbp > 47){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4266 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 4267 return -1; |
4268 } | |
4269 | |
4270 if(IS_INTRA4x4(mb_type)) | |
4271 cbp= golomb_to_intra4x4_cbp[cbp]; | |
4272 else | |
4273 cbp= golomb_to_inter_cbp[cbp]; | |
4274 } | |
4275 | |
4276 if(cbp || IS_INTRA16x16(mb_type)){ | |
4277 int i8x8, i4x4, chroma_idx; | |
4278 int chroma_qp, dquant; | |
4279 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
4280 const uint8_t *scan, *dc_scan; | |
4281 | |
4282 // fill_non_zero_count_cache(h); | |
4283 | |
4284 if(IS_INTERLACED(mb_type)){ | |
4285 scan= field_scan; | |
4286 dc_scan= luma_dc_field_scan; | |
4287 }else{ | |
4288 scan= zigzag_scan; | |
4289 dc_scan= luma_dc_zigzag_scan; | |
4290 } | |
4291 | |
4292 dquant= get_se_golomb(&s->gb); | |
4293 | |
4294 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4295 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 | 4296 return -1; |
4297 } | |
4298 | |
4299 s->qscale += dquant; | |
4300 if(((unsigned)s->qscale) > 51){ | |
4301 if(s->qscale<0) s->qscale+= 52; | |
4302 else s->qscale-= 52; | |
4303 } | |
4304 | |
4305 h->chroma_qp= chroma_qp= get_chroma_qp(h, s->qscale); | |
4306 if(IS_INTRA16x16(mb_type)){ | |
4307 if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, s->qscale, 16) < 0){ | |
4308 return -1; //FIXME continue if partotioned and other retirn -1 too | |
4309 } | |
4310 | |
4311 assert((cbp&15) == 0 || (cbp&15) == 15); | |
4312 | |
4313 if(cbp&15){ | |
4314 for(i8x8=0; i8x8<4; i8x8++){ | |
4315 for(i4x4=0; i4x4<4; i4x4++){ | |
4316 const int index= i4x4 + 4*i8x8; | |
4317 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, s->qscale, 15) < 0 ){ | |
4318 return -1; | |
4319 } | |
4320 } | |
4321 } | |
4322 }else{ | |
1636 | 4323 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 4324 } |
4325 }else{ | |
4326 for(i8x8=0; i8x8<4; i8x8++){ | |
4327 if(cbp & (1<<i8x8)){ | |
4328 for(i4x4=0; i4x4<4; i4x4++){ | |
4329 const int index= i4x4 + 4*i8x8; | |
4330 | |
4331 if( decode_residual(h, gb, h->mb + 16*index, index, scan, s->qscale, 16) <0 ){ | |
4332 return -1; | |
4333 } | |
4334 } | |
4335 }else{ | |
4336 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
4337 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
4338 } | |
4339 } | |
4340 } | |
4341 | |
4342 if(cbp&0x30){ | |
4343 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
4344 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, chroma_qp, 4) < 0){ | |
4345 return -1; | |
4346 } | |
4347 } | |
4348 | |
4349 if(cbp&0x20){ | |
4350 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
4351 for(i4x4=0; i4x4<4; i4x4++){ | |
4352 const int index= 16 + 4*chroma_idx + i4x4; | |
4353 if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, chroma_qp, 15) < 0){ | |
4354 return -1; | |
4355 } | |
4356 } | |
4357 } | |
4358 }else{ | |
4359 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
4360 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
4361 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
4362 } | |
4363 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4364 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
|
4365 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
|
4366 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
|
4367 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 4368 } |
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
|
4369 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 4370 write_back_non_zero_count(h); |
4371 | |
4372 return 0; | |
4373 } | |
4374 | |
2312 | 4375 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
4376 uint8_t *state= &h->cabac_state[ctx_base]; | |
4377 int mb_type; | |
4378 | |
4379 if(intra_slice){ | |
4380 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
|
4381 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4382 const int mba_xy = mb_xy - 1; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4383 const int mbb_xy = mb_xy - s->mb_stride; |
2312 | 4384 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4385 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4386 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4387 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4388 ctx++; |
2312 | 4389 if( get_cabac( &h->cabac, &state[ctx] ) == 0 ) |
4390 return 0; /* I4x4 */ | |
4391 state += 2; | |
4392 }else{ | |
4393 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
|
4394 return 0; /* I4x4 */ |
2312 | 4395 } |
4396 | |
4397 if( get_cabac_terminate( &h->cabac ) ) | |
4398 return 25; /* PCM */ | |
4399 | |
4400 mb_type = 1; /* I16x16 */ | |
4401 if( get_cabac( &h->cabac, &state[1] ) ) | |
4402 mb_type += 12; /* cbp_luma != 0 */ | |
4403 | |
4404 if( get_cabac( &h->cabac, &state[2] ) ) { | |
4405 if( get_cabac( &h->cabac, &state[2+intra_slice] ) ) | |
4406 mb_type += 4 * 2; /* cbp_chroma == 2 */ | |
4407 else | |
4408 mb_type += 4 * 1; /* cbp_chroma == 1 */ | |
4409 } | |
4410 if( get_cabac( &h->cabac, &state[3+intra_slice] ) ) | |
4411 mb_type += 2; | |
4412 if( get_cabac( &h->cabac, &state[3+2*intra_slice] ) ) | |
4413 mb_type += 1; | |
4414 return mb_type; | |
4415 } | |
4416 | |
4417 static int decode_cabac_mb_type( H264Context *h ) { | |
4418 MpegEncContext * const s = &h->s; | |
4419 | |
4420 if( h->slice_type == I_TYPE ) { | |
4421 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
|
4422 } 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
|
4423 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
|
4424 /* 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
|
4425 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
|
4426 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
|
4427 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
|
4428 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4429 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
|
4430 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4431 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
|
4432 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
|
4433 else |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4434 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
|
4435 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4436 } else { |
2312 | 4437 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
|
4438 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4439 } 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
|
4440 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4441 const int mba_xy = mb_xy - 1; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4442 const int mbb_xy = mb_xy - s->mb_stride; |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4443 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
|
4444 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4445 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4446 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ) |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4447 && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) ) |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4448 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4449 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ) |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4450 && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) ) |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4451 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4452 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4453 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
|
4454 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
|
4455 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4456 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
|
4457 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
|
4458 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4459 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4460 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
|
4461 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
|
4462 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
|
4463 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
|
4464 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
|
4465 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
|
4466 else if( bits == 13 ) { |
2312 | 4467 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
|
4468 } 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
|
4469 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
|
4470 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
|
4471 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
|
4472 |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4473 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
|
4474 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
|
4475 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4476 /* 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
|
4477 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
|
4478 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4479 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4480 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4481 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
|
4482 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
|
4483 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
|
4484 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
|
4485 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
|
4486 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
|
4487 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4488 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] )) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4489 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4490 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] )) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4491 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4492 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4493 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
|
4494 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
|
4495 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
|
4496 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
|
4497 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4498 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4499 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
|
4500 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
|
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 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
|
4503 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
|
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 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
|
4506 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
|
4507 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
|
4508 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
|
4509 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
|
4510 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
|
4511 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
|
4512 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
|
4513 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4514 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
|
4515 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4516 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4517 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
|
4518 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
|
4519 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
|
4520 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
|
4521 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
|
4522 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4523 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
|
4524 |
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
|
4525 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4526 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4527 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
|
4528 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4529 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4530 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4531 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4532 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
|
4533 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
|
4534 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4535 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
|
4536 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
|
4537 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
|
4538 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
|
4539 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4540 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
|
4541 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4542 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4543 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
|
4544 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
|
4545 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4546 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
|
4547 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
|
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 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
|
4550 { 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
|
4551 { 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
|
4552 { 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
|
4553 { 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
|
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 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
|
4557 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
|
4558 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
|
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 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
|
4561 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
|
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 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
|
4564 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4565 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
|
4566 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
|
4567 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
|
4568 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
|
4569 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
|
4570 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4571 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
|
4572 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
|
4573 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4574 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
|
4575 mba_xy = mb_xy; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4576 else if( s->mb_x > 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
|
4577 mba_xy = mb_xy - 1; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4578 if (h->slice_table[mba_xy] != h->slice_num) { |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4579 mba_xy = -1; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4580 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4581 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4582 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4583 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
|
4584 mbb_xy = mb_xy; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4585 else if( s->mb_y > 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
|
4586 mbb_xy = mb_xy - s->mb_stride; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4587 if (h->slice_table[mbb_xy] != h->slice_num) { |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4588 mbb_xy = -1; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4589 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4590 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4591 |
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
|
4592 /* 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
|
4593 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
|
4594 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
|
4595 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
|
4596 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4597 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4598 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4599 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
|
4600 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
|
4601 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
|
4602 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
|
4603 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4604 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4605 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
|
4606 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
|
4607 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
|
4608 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4609 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4610 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
|
4611 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4612 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
|
4613 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
|
4614 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
|
4615 |
2314 | 4616 cbp_a = (h->left_cbp>>4)&0x03; |
4617 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
|
4618 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4619 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
|
4620 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
|
4621 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
|
4622 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
|
4623 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
|
4624 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4625 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
|
4626 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
|
4627 if( cbp_b == 2 ) ctx += 2; |
2314 | 4628 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
|
4629 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4630 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
|
4631 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
|
4632 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
|
4633 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
|
4634 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
|
4635 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4636 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
|
4637 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
|
4638 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4639 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
|
4640 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4641 if( h->last_qscale_diff != 0 && ( IS_INTRA16x16(s->current_picture.mb_type[mbn_xy] ) || (h->cbp_table[mbn_xy]&0x3f) ) ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4642 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4643 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4644 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
|
4645 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
|
4646 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
|
4647 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4648 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
|
4649 val++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4650 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4651 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4652 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
|
4653 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
|
4654 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4655 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
|
4656 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4657 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
|
4658 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
|
4659 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
|
4660 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
|
4661 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
|
4662 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
|
4663 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
|
4664 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
|
4665 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4666 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
|
4667 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4668 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
|
4669 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
|
4670 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
|
4671 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
|
4672 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4673 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
|
4674 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
|
4675 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
|
4676 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4677 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4678 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
|
4679 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
|
4680 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4681 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4682 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4683 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
|
4684 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
|
4685 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
|
4686 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
|
4687 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
|
4688 |
2396 | 4689 if( h->slice_type == B_TYPE) { |
4690 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
4691 ctx++; | |
4692 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
4693 ctx += 2; | |
4694 } else { | |
4695 if( refa > 0 ) | |
4696 ctx++; | |
4697 if( refb > 0 ) | |
4698 ctx += 2; | |
4699 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4700 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4701 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
|
4702 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4703 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
|
4704 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4705 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4706 ctx = 5; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4707 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4708 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4709 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4710 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4711 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
|
4712 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
|
4713 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
|
4714 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 4715 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
|
4716 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4717 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
|
4718 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4719 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
|
4720 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4721 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4722 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4723 |
2317 | 4724 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
4725 return 0; | |
4726 | |
4727 mvd= 1; | |
4728 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
|
4729 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
|
4730 mvd++; |
2317 | 4731 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
|
4732 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4733 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4734 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4735 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
|
4736 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
|
4737 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
|
4738 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
|
4739 k++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4740 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4741 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4742 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
|
4743 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
|
4744 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4745 } |
2317 | 4746 if( get_cabac_bypass( &h->cabac ) ) return -mvd; |
4747 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
|
4748 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4749 |
2316 | 4750 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 4751 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
|
4752 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
|
4753 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4754 if( cat == 0 ) { |
2314 | 4755 nza = h->left_cbp&0x100; |
4756 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
|
4757 } else if( cat == 1 || cat == 2 ) { |
2314 | 4758 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
4759 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
|
4760 } else if( cat == 3 ) { |
2314 | 4761 nza = (h->left_cbp>>(6+idx))&0x01; |
4762 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
4763 } else { | |
4764 assert(cat == 4); | |
4765 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
4766 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
4767 } | |
4768 | |
4769 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
|
4770 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4771 |
2314 | 4772 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
|
4773 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
|
4774 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4775 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
|
4776 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4777 |
2316 | 4778 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
|
4779 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
|
4780 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
|
4781 static const int significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 }; |
2313 | 4782 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
|
4783 |
2313 | 4784 int index[16]; |
4785 | |
4786 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
|
4787 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
|
4788 |
2316 | 4789 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
|
4790 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
|
4791 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4792 /* 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
|
4793 * 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
|
4794 * 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
|
4795 * 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
|
4796 * 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
|
4797 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4798 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4799 /* 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
|
4800 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
|
4801 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
|
4802 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
|
4803 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
|
4804 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
|
4805 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4806 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
|
4807 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4808 |
2313 | 4809 for(last= 0; last < max_coeff - 1; last++) { |
4810 if( get_cabac( &h->cabac, &h->cabac_state[105+significant_coeff_flag_offset[cat]+last] )) { | |
4811 index[coeff_count++] = last; | |
4812 if( get_cabac( &h->cabac, &h->cabac_state[166+significant_coeff_flag_offset[cat]+last] ) ) { | |
4813 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
|
4814 break; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4815 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4816 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4817 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4818 if( last == max_coeff -1 ) { |
2313 | 4819 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
|
4820 } |
2316 | 4821 assert(coeff_count > 0); |
4822 | |
4823 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
|
4824 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
|
4825 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
|
4826 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 4827 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
|
4828 h->cbp_table[mb_xy] |= 0x40 << n; |
2316 | 4829 else { |
4830 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
|
4831 h->non_zero_count_cache[scan8[16+n]] = coeff_count; |
2316 | 4832 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4833 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4834 for( i = coeff_count - 1; i >= 0; i-- ) { |
2316 | 4835 int ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + coeff_abs_level_m1_offset[cat]; |
4836 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
|
4837 |
2313 | 4838 if( get_cabac( &h->cabac, &h->cabac_state[ctx] ) == 0 ) { |
2316 | 4839 if( cat == 0 || cat == 3 ) { |
4840 if( get_cabac_bypass( &h->cabac ) ) block[j] = -1; | |
4841 else block[j] = 1; | |
4842 }else{ | |
4843 if( get_cabac_bypass( &h->cabac ) ) block[j] = -qmul[j]; | |
4844 else block[j] = qmul[j]; | |
4845 } | |
2313 | 4846 |
4847 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
|
4848 } else { |
2313 | 4849 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
|
4850 ctx = 5 + FFMIN( 4, abslevelgt1 ) + coeff_abs_level_m1_offset[cat]; |
2313 | 4851 while( coeff_abs < 15 && get_cabac( &h->cabac, &h->cabac_state[ctx] ) ) { |
4852 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
|
4853 } |
2313 | 4854 |
4855 if( coeff_abs >= 15 ) { | |
4856 int j = 0; | |
4857 while( get_cabac_bypass( &h->cabac ) ) { | |
4858 coeff_abs += 1 << j; | |
4859 j++; | |
4860 } | |
4861 | |
4862 while( j-- ) { | |
4863 if( get_cabac_bypass( &h->cabac ) ) | |
4864 coeff_abs += 1 << j ; | |
4865 } | |
4866 } | |
4867 | |
2316 | 4868 if( cat == 0 || cat == 3 ) { |
4869 if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs; | |
4870 else block[j] = coeff_abs; | |
4871 }else{ | |
4872 if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs * qmul[j]; | |
4873 else block[j] = coeff_abs * qmul[j]; | |
4874 } | |
2313 | 4875 |
4876 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
|
4877 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4878 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4879 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
|
4880 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4881 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4882 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4883 * 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
|
4884 * @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
|
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 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
|
4887 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
|
4888 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
|
4889 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
|
4890 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4891 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
|
4892 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4893 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
|
4894 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
|
4895 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
|
4896 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4897 |
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
|
4898 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
|
4899 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
|
4900 /* 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
|
4901 if( decode_cabac_mb_skip( h ) ) { |
2396 | 4902 decode_mb_skip(h); |
4903 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4904 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
|
4905 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
|
4906 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
|
4907 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4908 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
|
4909 |
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4912 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
|
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( ( 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
|
4915 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
|
4916 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
|
4917 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4918 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4919 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
|
4920 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
|
4921 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
|
4922 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
|
4923 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4924 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
|
4925 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
|
4926 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4927 } 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
|
4928 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
|
4929 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
|
4930 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
|
4931 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4932 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
|
4933 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
|
4934 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4935 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4936 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
|
4937 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
|
4938 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
|
4939 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
|
4940 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
|
4941 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
|
4942 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4943 #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
|
4944 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
|
4945 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
|
4946 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4947 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4948 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
|
4949 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
|
4950 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4951 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4952 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4953 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4954 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4955 // We assume these blocks are very rare so we dont optimize it. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4956 // FIXME The two following lines get the bitstream position in the cabac |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4957 // decode, I think it should be done by a function in cabac.h (or cabac.c). |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4958 ptr= h->cabac.bytestream; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4959 if (h->cabac.low&0x1) ptr-=CABAC_BITS/8; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4960 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4961 // The pixels are stored in the same order as levels in h->mb array. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4962 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4963 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4964 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4965 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4966 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4967 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4968 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4969 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4970 const int index= 256 + 4*(y&3) + 32*(y>>2); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4971 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4972 tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4973 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4974 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4975 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4976 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4977 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4978 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4979 tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4980 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4981 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4982 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4983 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4984 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4985 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4986 // All blocks are presents |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4987 h->cbp_table[mb_xy] = 0x1ef; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4988 h->chroma_pred_mode_table[mb_xy] = 0; |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4989 // In deblocking, the quantiser is 0 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4990 s->current_picture.qscale_table[mb_xy]= 0; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4991 h->chroma_qp = get_chroma_qp(h, 0); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4992 // All coeffs are presents |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4993 memset(h->non_zero_count[mb_xy], 16, 16); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4994 return 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4995 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4996 |
2449 | 4997 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
|
4998 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4999 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
|
5000 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
|
5001 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
|
5002 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
|
5003 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
|
5004 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
|
5005 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5006 //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
|
5007 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5008 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
|
5009 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
|
5010 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5011 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
|
5012 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
|
5013 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5014 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
|
5015 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
|
5016 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5017 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
|
5018 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
|
5019 } 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
|
5020 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
|
5021 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5022 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
|
5023 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
|
5024 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
|
5025 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
|
5026 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
|
5027 } |
2396 | 5028 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
5029 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { | |
5030 pred_direct_motion(h, &mb_type); | |
5031 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
5032 for( i = 0; i < 4; i++ ) | |
5033 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
5034 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
5035 } | |
5036 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5037 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5038 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
|
5039 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
|
5040 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
|
5041 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
|
5042 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5043 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5044 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5045 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
|
5046 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
|
5047 for( i = 0; i < 4; i++ ) { |
2396 | 5048 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5049 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
|
5050 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
|
5051 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
|
5052 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5053 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
|
5054 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5055 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
|
5056 } |
2110 | 5057 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
|
5058 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
|
5059 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5060 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5061 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5062 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5063 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
|
5064 for(i=0; i<4; i++){ |
2396 | 5065 if(IS_DIRECT(h->sub_mb_type[i])){ |
5066 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
5067 continue; | |
5068 } | |
2110 | 5069 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
|
5070 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5071 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
|
5072 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
|
5073 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
|
5074 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
|
5075 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
|
5076 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
|
5077 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
|
5078 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
|
5079 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
|
5080 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
|
5081 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5082 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
|
5083 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
|
5084 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
|
5085 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5086 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
|
5087 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
|
5088 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
|
5089 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
|
5090 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
|
5091 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5092 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
|
5093 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
|
5094 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
|
5095 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
|
5096 }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
|
5097 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
|
5098 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
|
5099 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5100 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
|
5101 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
|
5102 }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
|
5103 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
|
5104 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
|
5105 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5106 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
|
5107 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
|
5108 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5109 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
|
5110 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
|
5111 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
|
5112 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5113 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
|
5114 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
|
5115 } |
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 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5118 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
|
5119 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
|
5120 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
|
5121 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
|
5122 } |
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 } |
2396 | 5125 } else if( IS_DIRECT(mb_type) ) { |
5126 pred_direct_motion(h, &mb_type); | |
5127 s->current_picture.mb_type[mb_xy]= mb_type; | |
5128 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
5129 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
5130 } else { | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5131 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
|
5132 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
|
5133 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
|
5134 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
|
5135 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
|
5136 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
|
5137 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
|
5138 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5139 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5140 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5141 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
|
5142 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
|
5143 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
|
5144 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5145 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
|
5146 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
|
5147 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
|
5148 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5149 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
|
5150 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
|
5151 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5152 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5153 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5154 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
|
5155 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
|
5156 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
|
5157 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
|
5158 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
|
5159 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
|
5160 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 5161 }else |
5162 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
|
5163 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5164 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5165 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5166 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
|
5167 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
|
5168 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
|
5169 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
|
5170 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
|
5171 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
|
5172 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
|
5173 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5174 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
|
5175 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5176 }else{ // needed only for mixed refs |
5177 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
5178 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
|
5179 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5180 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5181 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5182 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5183 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
|
5184 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
|
5185 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
|
5186 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
|
5187 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
|
5188 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
|
5189 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 5190 }else |
5191 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
|
5192 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5193 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5194 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5195 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
|
5196 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
|
5197 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
|
5198 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
|
5199 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
|
5200 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
|
5201 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5202 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
|
5203 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
|
5204 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5205 }else{ // needed only for mixed refs |
5206 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
5207 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
|
5208 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5209 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5210 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5211 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5212 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5213 |
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
|
5214 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
|
5215 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
|
5216 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
|
5217 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5218 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5219 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
|
5220 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
|
5221 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5224 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
|
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 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
|
5227 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
|
5228 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
|
5229 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5230 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
|
5231 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
|
5232 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
|
5233 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5234 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
|
5235 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
|
5236 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5237 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5238 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
|
5239 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
|
5240 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
|
5241 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
|
5242 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
|
5243 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5244 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
|
5245 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5246 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
|
5247 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
|
5248 //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
|
5249 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
|
5250 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
|
5251 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
|
5252 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
|
5253 //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
|
5254 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
|
5255 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
|
5256 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5257 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5258 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
|
5259 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5260 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5261 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
|
5262 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
|
5263 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
|
5264 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
|
5265 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
|
5266 //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
|
5267 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
|
5268 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
|
5269 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5270 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5271 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
|
5272 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
|
5273 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5274 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5275 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5276 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5277 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
|
5278 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
|
5279 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
|
5280 //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
|
5281 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
|
5282 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
|
5283 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5284 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5285 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5286 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
|
5287 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
|
5288 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
|
5289 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
|
5290 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
|
5291 //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
|
5292 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
|
5293 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
|
5294 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5295 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5296 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5297 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
|
5298 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
|
5299 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
|
5300 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5301 } else { |
2315 | 5302 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
5303 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
5304 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5305 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
|
5306 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5307 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5308 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
|
5309 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
|
5310 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5311 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
|
5312 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5313 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5314 |
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
|
5315 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
|
5316 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
|
5317 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
|
5318 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
|
5319 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
|
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 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
|
5322 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
|
5323 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
|
5324 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
|
5325 } |
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 |
1898 | 5327 if( bS[i] < 4 ) { |
5328 const int tc0 = tc0_table[index_a][bS[i] - 1]; | |
5329 /* 4px edge length */ | |
5330 for( d = 0; d < 4; d++ ) { | |
5331 const int p0 = pix[-1]; | |
5332 const int p1 = pix[-2]; | |
5333 const int p2 = pix[-3]; | |
5334 const int q0 = pix[0]; | |
5335 const int q1 = pix[1]; | |
5336 const int q2 = pix[2]; | |
5337 | |
5338 if( ABS( p0 - q0 ) < alpha && | |
5339 ABS( p1 - p0 ) < beta && | |
5340 ABS( q1 - q0 ) < beta ) { | |
5341 int tc = tc0; | |
5342 int i_delta; | |
5343 | |
5344 if( ABS( p2 - p0 ) < beta ) { | |
5345 pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5346 tc++; | |
5347 } | |
5348 if( ABS( q2 - q0 ) < beta ) { | |
5349 pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5350 tc++; | |
5351 } | |
5352 | |
5353 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5354 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5355 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
|
5356 } |
1898 | 5357 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
|
5358 } |
1898 | 5359 }else{ |
5360 /* 4px edge length */ | |
5361 for( d = 0; d < 4; d++ ) { | |
5362 const int p0 = pix[-1]; | |
5363 const int p1 = pix[-2]; | |
5364 const int p2 = pix[-3]; | |
5365 | |
5366 const int q0 = pix[0]; | |
5367 const int q1 = pix[1]; | |
5368 const int q2 = pix[2]; | |
5369 | |
5370 if( ABS( p0 - q0 ) < alpha && | |
5371 ABS( p1 - p0 ) < beta && | |
5372 ABS( q1 - q0 ) < beta ) { | |
5373 | |
5374 if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
5375 if( ABS( p2 - p0 ) < beta) | |
5376 { | |
5377 const int p3 = pix[-4]; | |
5378 /* p0', p1', p2' */ | |
5379 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
5380 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
5381 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
5382 } else { | |
5383 /* p0' */ | |
5384 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5385 } | |
5386 if( ABS( q2 - q0 ) < beta) | |
5387 { | |
5388 const int q3 = pix[3]; | |
5389 /* q0', q1', q2' */ | |
5390 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
5391 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
5392 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
5393 } else { | |
5394 /* q0' */ | |
5395 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5396 } | |
5397 }else{ | |
5398 /* p0', q0' */ | |
5399 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5400 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5401 } | |
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
|
5402 } |
1898 | 5403 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
|
5404 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5405 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5406 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5407 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5408 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
|
5409 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
|
5410 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
|
5411 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
|
5412 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
|
5413 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5414 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
|
5415 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
|
5416 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
|
5417 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
|
5418 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5419 |
1898 | 5420 if( bS[i] < 4 ) { |
5421 const int tc = tc0_table[index_a][bS[i] - 1] + 1; | |
5422 /* 2px edge length (because we use same bS than the one for luma) */ | |
5423 for( d = 0; d < 2; d++ ){ | |
5424 const int p0 = pix[-1]; | |
5425 const int p1 = pix[-2]; | |
5426 const int q0 = pix[0]; | |
5427 const int q1 = pix[1]; | |
5428 | |
5429 if( ABS( p0 - q0 ) < alpha && | |
5430 ABS( p1 - p0 ) < beta && | |
5431 ABS( q1 - q0 ) < beta ) { | |
5432 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5433 | |
5434 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5435 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
|
5436 //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 | 5437 } |
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
|
5438 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
|
5439 } |
1898 | 5440 }else{ |
5441 /* 2px edge length (because we use same bS than the one for luma) */ | |
5442 for( d = 0; d < 2; d++ ){ | |
5443 const int p0 = pix[-1]; | |
5444 const int p1 = pix[-2]; | |
5445 const int q0 = pix[0]; | |
5446 const int q1 = pix[1]; | |
5447 | |
5448 if( ABS( p0 - q0 ) < alpha && | |
5449 ABS( p1 - p0 ) < beta && | |
5450 ABS( q1 - q0 ) < beta ) { | |
5451 | |
5452 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */ | |
5453 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
|
5454 //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 | 5455 } |
5456 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
|
5457 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5458 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5459 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5460 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5461 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5462 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
|
5463 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
|
5464 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
|
5465 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
|
5466 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
|
5467 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
|
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 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
|
5470 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
|
5471 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
|
5472 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
|
5473 } |
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 |
1898 | 5475 if( bS[i] < 4 ) { |
5476 const int tc0 = tc0_table[index_a][bS[i] - 1]; | |
5477 /* 4px edge length */ | |
5478 for( d = 0; d < 4; d++ ) { | |
5479 const int p0 = pix[-1*pix_next]; | |
5480 const int p1 = pix[-2*pix_next]; | |
5481 const int p2 = pix[-3*pix_next]; | |
5482 const int q0 = pix[0]; | |
5483 const int q1 = pix[1*pix_next]; | |
5484 const int q2 = pix[2*pix_next]; | |
5485 | |
5486 if( ABS( p0 - q0 ) < alpha && | |
5487 ABS( p1 - p0 ) < beta && | |
5488 ABS( q1 - q0 ) < beta ) { | |
5489 | |
5490 int tc = tc0; | |
5491 int i_delta; | |
5492 | |
5493 if( ABS( p2 - p0 ) < beta ) { | |
5494 pix[-2*pix_next] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5495 tc++; | |
5496 } | |
5497 if( ABS( q2 - q0 ) < beta ) { | |
5498 pix[pix_next] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); | |
5499 tc++; | |
5500 } | |
5501 | |
5502 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5503 pix[-pix_next] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5504 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
|
5505 } |
1898 | 5506 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
|
5507 } |
1898 | 5508 }else{ |
5509 /* 4px edge length */ | |
5510 for( d = 0; d < 4; d++ ) { | |
5511 const int p0 = pix[-1*pix_next]; | |
5512 const int p1 = pix[-2*pix_next]; | |
5513 const int p2 = pix[-3*pix_next]; | |
5514 const int q0 = pix[0]; | |
5515 const int q1 = pix[1*pix_next]; | |
5516 const int q2 = pix[2*pix_next]; | |
5517 | |
5518 if( ABS( p0 - q0 ) < alpha && | |
5519 ABS( p1 - p0 ) < beta && | |
5520 ABS( q1 - q0 ) < beta ) { | |
5521 | |
5522 const int p3 = pix[-4*pix_next]; | |
5523 const int q3 = pix[ 3*pix_next]; | |
5524 | |
5525 if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
5526 if( ABS( p2 - p0 ) < beta) { | |
5527 /* p0', p1', p2' */ | |
5528 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
5529 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
5530 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
5531 } else { | |
5532 /* p0' */ | |
5533 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5534 } | |
5535 if( ABS( q2 - q0 ) < beta) { | |
5536 /* q0', q1', q2' */ | |
5537 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
5538 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
5539 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
5540 } else { | |
5541 /* q0' */ | |
5542 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5543 } | |
5544 }else{ | |
5545 /* p0', q0' */ | |
5546 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5547 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5548 } | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5549 } |
1898 | 5550 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
|
5551 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5552 } |
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 } |
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 } |
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 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
|
5557 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
|
5558 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
|
5559 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
|
5560 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
|
5561 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
|
5562 |
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 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
|
5564 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5565 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
|
5566 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
|
5567 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
|
5568 } |
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 |
1898 | 5570 if( bS[i] < 4 ) { |
5571 int tc = tc0_table[index_a][bS[i] - 1] + 1; | |
5572 /* 2px edge length (see deblocking_filter_edgecv) */ | |
5573 for( d = 0; d < 2; d++ ) { | |
5574 const int p0 = pix[-1*pix_next]; | |
5575 const int p1 = pix[-2*pix_next]; | |
5576 const int q0 = pix[0]; | |
5577 const int q1 = pix[1*pix_next]; | |
5578 | |
5579 if( ABS( p0 - q0 ) < alpha && | |
5580 ABS( p1 - p0 ) < beta && | |
5581 ABS( q1 - q0 ) < beta ) { | |
5582 | |
5583 int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); | |
5584 | |
5585 pix[-pix_next] = clip_uint8( p0 + i_delta ); /* p0' */ | |
5586 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ | |
5587 } | |
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
|
5588 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
|
5589 } |
1898 | 5590 }else{ |
5591 /* 2px edge length (see deblocking_filter_edgecv) */ | |
5592 for( d = 0; d < 2; d++ ) { | |
5593 const int p0 = pix[-1*pix_next]; | |
5594 const int p1 = pix[-2*pix_next]; | |
5595 const int q0 = pix[0]; | |
5596 const int q1 = pix[1*pix_next]; | |
5597 | |
5598 if( ABS( p0 - q0 ) < alpha && | |
5599 ABS( p1 - p0 ) < beta && | |
5600 ABS( q1 - q0 ) < beta ) { | |
5601 | |
5602 pix[-pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */ | |
5603 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ | |
5604 } | |
5605 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
|
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 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5611 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
|
5612 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
|
5613 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
|
5614 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
|
5615 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
|
5616 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5617 /* 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
|
5618 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
|
5619 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
|
5620 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5621 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
|
5622 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
|
5623 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5624 /* 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
|
5625 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
|
5626 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5627 int edge; |
2454 | 5628 const int mbm_xy = dir == 0 ? mb_xy -1 : mb_xy - s->mb_stride; |
5629 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; | |
5630 | |
5631 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
|
5632 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
|
5633 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5634 /* 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
|
5635 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
|
5636 /* mbn_xy: neighbour macroblock (how that works for field ?) */ |
2454 | 5637 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
|
5638 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
|
5639 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
|
5640 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5641 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
|
5642 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
|
5643 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
|
5644 } 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
|
5645 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
|
5646 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
|
5647 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
|
5648 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
|
5649 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
|
5650 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
|
5651 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5652 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 5653 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
|
5654 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
|
5655 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5656 else if( h->slice_type == P_TYPE ) { |
2449 | 5657 if( h->ref_cache[0][b_idx] != h->ref_cache[0][bn_idx] || |
5658 ABS( h->mv_cache[0][b_idx][0] - h->mv_cache[0][bn_idx][0] ) >= 4 || | |
5659 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
|
5660 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
|
5661 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
|
5662 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
|
5663 } 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
|
5664 /* 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
|
5665 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
|
5666 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5667 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5668 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5669 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
|
5670 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
|
5671 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5672 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5673 /* Filter edge */ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5674 // Do not use s->qscale as luma quantiser because it has not the same |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5675 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5676 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
5677 //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
|
5678 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
|
5679 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 5680 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
|
5681 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
|
5682 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
|
5683 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
|
5684 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
|
5685 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5686 } 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
|
5687 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 5688 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
|
5689 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
|
5690 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
|
5691 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
|
5692 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
|
5693 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5694 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5695 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5696 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5697 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5698 |
1168 | 5699 static int decode_slice(H264Context *h){ |
5700 MpegEncContext * const s = &h->s; | |
5701 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
5702 | |
5703 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
|
5704 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5705 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
|
5706 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
|
5707 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5708 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5709 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
|
5710 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5711 /* 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
|
5712 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
|
5713 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
|
5714 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 5715 ( 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
|
5716 /* 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
|
5717 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
|
5718 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
|
5719 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
|
5720 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
|
5721 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5722 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
|
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 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
|
5725 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
|
5726 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5727 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 5728 } |
5729 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5730 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5731 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
|
5732 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
|
5733 |
2163 | 5734 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
|
5735 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5736 /* 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
|
5737 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
|
5738 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
|
5739 |
2163 | 5740 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
|
5741 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
|
5742 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5743 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
|
5744 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
|
5745 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5746 |
2116 | 5747 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
|
5748 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
|
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); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5750 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
|
5751 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5752 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5753 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
|
5754 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
|
5755 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 5756 ++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
|
5757 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5758 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5759 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 5760 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
|
5761 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
|
5762 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
|
5763 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5764 #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
|
5765 /* 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
|
5766 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
|
5767 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
|
5768 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
|
5769 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5770 #endif |
1168 | 5771 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5772 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5773 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5774 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5775 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
|
5776 |
2163 | 5777 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
|
5778 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5779 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
|
5780 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
|
5781 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
|
5782 |
2163 | 5783 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
|
5784 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
|
5785 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5786 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5787 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
|
5788 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
|
5789 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
|
5790 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5791 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
|
5792 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5793 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5794 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
|
5795 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
|
5796 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
|
5797 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
|
5798 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
|
5799 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5800 if(get_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
|
5801 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
|
5802 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5803 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
|
5804 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5805 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
|
5806 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5807 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
|
5808 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5809 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5810 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5811 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5812 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 5813 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
|
5814 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 5815 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); |
5816 | |
5817 return 0; | |
5818 }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
|
5819 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 | 5820 |
5821 return -1; | |
5822 } | |
5823 } | |
5824 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5825 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5826 |
1168 | 5827 #if 0 |
5828 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
5829 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
5830 int ret= decode_mb(h); | |
5831 | |
5832 hl_decode_mb(h); | |
5833 | |
5834 if(ret<0){ | |
5835 fprintf(stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); | |
5836 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); | |
5837 | |
5838 return -1; | |
5839 } | |
5840 | |
5841 if(++s->mb_x >= s->mb_width){ | |
5842 s->mb_x=0; | |
5843 if(++s->mb_y >= s->mb_height){ | |
5844 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
5845 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); | |
5846 | |
5847 return 0; | |
5848 }else{ | |
5849 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); | |
5850 | |
5851 return -1; | |
5852 } | |
5853 } | |
5854 } | |
5855 | |
5856 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ | |
5857 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
5858 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); | |
5859 | |
5860 return 0; | |
5861 }else{ | |
5862 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); | |
5863 | |
5864 return -1; | |
5865 } | |
5866 } | |
5867 } | |
5868 s->mb_x=0; | |
5869 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
5870 } | |
5871 #endif | |
5872 return -1; //not reached | |
5873 } | |
5874 | |
5875 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ | |
5876 MpegEncContext * const s = &h->s; | |
5877 int aspect_ratio_info_present_flag, aspect_ratio_idc; | |
5878 | |
5879 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
5880 | |
5881 if( aspect_ratio_info_present_flag ) { | |
5882 aspect_ratio_idc= get_bits(&s->gb, 8); | |
5883 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 5884 sps->sar.num= get_bits(&s->gb, 16); |
5885 sps->sar.den= get_bits(&s->gb, 16); | |
1168 | 5886 }else if(aspect_ratio_idc < 16){ |
1548 | 5887 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 5888 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5889 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 5890 return -1; |
5891 } | |
5892 }else{ | |
1548 | 5893 sps->sar.num= |
5894 sps->sar.den= 0; | |
1168 | 5895 } |
5896 // 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
|
5897 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5898 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
|
5899 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
|
5900 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5901 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5902 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
|
5903 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
|
5904 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
|
5905 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
|
5906 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
|
5907 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
|
5908 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
|
5909 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5910 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5911 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5912 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
|
5913 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
|
5914 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
|
5915 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5916 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5917 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
|
5918 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
|
5919 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
|
5920 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
|
5921 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
|
5922 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
5923 |
1168 | 5924 #if 0 |
5925 | nal_hrd_parameters_present_flag |0 |u(1) | | |
5926 | if( nal_hrd_parameters_present_flag = = 1) | | | | |
5927 | hrd_parameters( ) | | | | |
5928 | vcl_hrd_parameters_present_flag |0 |u(1) | | |
5929 | if( vcl_hrd_parameters_present_flag = = 1) | | | | |
5930 | hrd_parameters( ) | | | | |
5931 | if( ( nal_hrd_parameters_present_flag = = 1 | || | | | |
5932 | | | | | |
5933 |( vcl_hrd_parameters_present_flag = = 1 ) ) | | | | |
5934 | low_delay_hrd_flag |0 |u(1) | | |
5935 | bitstream_restriction_flag |0 |u(1) | | |
5936 | if( bitstream_restriction_flag ) { |0 |u(1) | | |
5937 | motion_vectors_over_pic_boundaries_flag |0 |u(1) | | |
5938 | max_bytes_per_pic_denom |0 |ue(v) | | |
5939 | max_bits_per_mb_denom |0 |ue(v) | | |
5940 | log2_max_mv_length_horizontal |0 |ue(v) | | |
5941 | log2_max_mv_length_vertical |0 |ue(v) | | |
5942 | num_reorder_frames |0 |ue(v) | | |
5943 | max_dec_frame_buffering |0 |ue(v) | | |
5944 | } | | | | |
5945 |} | | | | |
5946 #endif | |
5947 return 0; | |
5948 } | |
5949 | |
5950 static inline int decode_seq_parameter_set(H264Context *h){ | |
5951 MpegEncContext * const s = &h->s; | |
1371 | 5952 int profile_idc, level_idc; |
1168 | 5953 int sps_id, i; |
5954 SPS *sps; | |
5955 | |
5956 profile_idc= get_bits(&s->gb, 8); | |
1371 | 5957 get_bits1(&s->gb); //constraint_set0_flag |
5958 get_bits1(&s->gb); //constraint_set1_flag | |
5959 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 5960 get_bits1(&s->gb); //constraint_set3_flag |
5961 get_bits(&s->gb, 4); // reserved | |
1168 | 5962 level_idc= get_bits(&s->gb, 8); |
5963 sps_id= get_ue_golomb(&s->gb); | |
5964 | |
5965 sps= &h->sps_buffer[ sps_id ]; | |
5966 sps->profile_idc= profile_idc; | |
5967 sps->level_idc= level_idc; | |
2312 | 5968 |
1168 | 5969 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
5970 sps->poc_type= get_ue_golomb(&s->gb); | |
5971 | |
5972 if(sps->poc_type == 0){ //FIXME #define | |
5973 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
5974 } else if(sps->poc_type == 1){//FIXME #define | |
5975 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
5976 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
5977 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
5978 sps->poc_cycle_length= get_ue_golomb(&s->gb); | |
5979 | |
5980 for(i=0; i<sps->poc_cycle_length; i++) | |
5981 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
5982 } | |
5983 if(sps->poc_type > 2){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5984 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 5985 return -1; |
5986 } | |
5987 | |
5988 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
|
5989 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
|
5990 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
|
5991 } |
1371 | 5992 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
1168 | 5993 sps->mb_width= get_ue_golomb(&s->gb) + 1; |
5994 sps->mb_height= get_ue_golomb(&s->gb) + 1; | |
2422 | 5995 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 || |
5996 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)) | |
5997 return -1; | |
5998 | |
1168 | 5999 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
6000 if(!sps->frame_mbs_only_flag) | |
6001 sps->mb_aff= get_bits1(&s->gb); | |
6002 else | |
6003 sps->mb_aff= 0; | |
6004 | |
6005 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
6006 | |
1371 | 6007 sps->crop= get_bits1(&s->gb); |
6008 if(sps->crop){ | |
6009 sps->crop_left = get_ue_golomb(&s->gb); | |
6010 sps->crop_right = get_ue_golomb(&s->gb); | |
6011 sps->crop_top = get_ue_golomb(&s->gb); | |
6012 sps->crop_bottom= get_ue_golomb(&s->gb); | |
6013 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
|
6014 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completly supported, this could look slightly wrong ...\n"); |
1371 | 6015 } |
6016 }else{ | |
6017 sps->crop_left = | |
6018 sps->crop_right = | |
6019 sps->crop_top = | |
6020 sps->crop_bottom= 0; | |
6021 } | |
6022 | |
1168 | 6023 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
6024 if( sps->vui_parameters_present_flag ) | |
6025 decode_vui_parameters(h, sps); | |
6026 | |
6027 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
|
6028 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 | 6029 sps_id, sps->profile_idc, sps->level_idc, |
6030 sps->poc_type, | |
6031 sps->ref_frame_count, | |
6032 sps->mb_width, sps->mb_height, | |
6033 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
6034 sps->direct_8x8_inference_flag ? "8B8" : "", | |
1371 | 6035 sps->crop_left, sps->crop_right, |
6036 sps->crop_top, sps->crop_bottom, | |
1168 | 6037 sps->vui_parameters_present_flag ? "VUI" : "" |
6038 ); | |
6039 } | |
6040 return 0; | |
6041 } | |
6042 | |
6043 static inline int decode_picture_parameter_set(H264Context *h){ | |
6044 MpegEncContext * const s = &h->s; | |
6045 int pps_id= get_ue_golomb(&s->gb); | |
6046 PPS *pps= &h->pps_buffer[pps_id]; | |
6047 | |
6048 pps->sps_id= get_ue_golomb(&s->gb); | |
6049 pps->cabac= get_bits1(&s->gb); | |
6050 pps->pic_order_present= get_bits1(&s->gb); | |
6051 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
6052 if(pps->slice_group_count > 1 ){ | |
6053 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
|
6054 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 6055 switch(pps->mb_slice_group_map_type){ |
6056 case 0: | |
6057 #if 0 | |
6058 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
6059 | run_length[ i ] |1 |ue(v) | | |
6060 #endif | |
6061 break; | |
6062 case 2: | |
6063 #if 0 | |
6064 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
6065 |{ | | | | |
6066 | top_left_mb[ i ] |1 |ue(v) | | |
6067 | bottom_right_mb[ i ] |1 |ue(v) | | |
6068 | } | | | | |
6069 #endif | |
6070 break; | |
6071 case 3: | |
6072 case 4: | |
6073 case 5: | |
6074 #if 0 | |
6075 | slice_group_change_direction_flag |1 |u(1) | | |
6076 | slice_group_change_rate_minus1 |1 |ue(v) | | |
6077 #endif | |
6078 break; | |
6079 case 6: | |
6080 #if 0 | |
6081 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
6082 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
6083 |) | | | | |
6084 | slice_group_id[ i ] |1 |u(v) | | |
6085 #endif | |
1214 | 6086 break; |
1168 | 6087 } |
6088 } | |
6089 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
6090 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
6091 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
|
6092 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
1168 | 6093 return -1; |
6094 } | |
6095 | |
6096 pps->weighted_pred= get_bits1(&s->gb); | |
6097 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
6098 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
6099 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
6100 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
6101 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
6102 pps->constrained_intra_pred= get_bits1(&s->gb); | |
6103 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
6104 | |
6105 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
|
6106 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 | 6107 pps_id, pps->sps_id, |
6108 pps->cabac ? "CABAC" : "CAVLC", | |
6109 pps->slice_group_count, | |
6110 pps->ref_count[0], pps->ref_count[1], | |
6111 pps->weighted_pred ? "weighted" : "", | |
6112 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
6113 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
6114 pps->constrained_intra_pred ? "CONSTR" : "", | |
1371 | 6115 pps->redundant_pic_cnt_present ? "REDU" : "" |
1168 | 6116 ); |
6117 } | |
6118 | |
6119 return 0; | |
6120 } | |
6121 | |
6122 /** | |
6123 * finds the end of the current frame in the bitstream. | |
6124 * @return the position of the first byte of the next frame, or -1 | |
6125 */ | |
2392 | 6126 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 6127 int i; |
1168 | 6128 uint32_t state; |
2392 | 6129 ParseContext *pc = &(h->s.parse_context); |
1168 | 6130 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
6131 // mb_addr= pc->mb_addr - 1; | |
6132 state= pc->state; | |
2392 | 6133 for(i=0; i<=buf_size; i++){ |
1168 | 6134 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 6135 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 6136 if(pc->frame_start_found){ |
2392 | 6137 // If there isn't one more byte in the buffer |
6138 // the test on first_mb_in_slice cannot be done yet | |
6139 // do it at next call. | |
6140 if (i >= buf_size) break; | |
6141 if (buf[i] & 0x80) { | |
6142 // first_mb_in_slice is 0, probably the first nal of a new | |
6143 // slice | |
6144 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
6145 pc->state=-1; | |
6146 pc->frame_start_found= 0; | |
6147 return i-4; | |
6148 } | |
1168 | 6149 } |
2392 | 6150 pc->frame_start_found = 1; |
1168 | 6151 } |
2392 | 6152 if (i<buf_size) |
6153 state= (state<<8) | buf[i]; | |
1168 | 6154 } |
6155 | |
6156 pc->state= state; | |
1219 | 6157 return END_NOT_FOUND; |
1168 | 6158 } |
6159 | |
1988 | 6160 static int h264_parse(AVCodecParserContext *s, |
6161 AVCodecContext *avctx, | |
6162 uint8_t **poutbuf, int *poutbuf_size, | |
6163 const uint8_t *buf, int buf_size) | |
6164 { | |
2392 | 6165 H264Context *h = s->priv_data; |
6166 ParseContext *pc = &h->s.parse_context; | |
1988 | 6167 int next; |
6168 | |
2392 | 6169 next= find_frame_end(h, buf, buf_size); |
1988 | 6170 |
6171 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
6172 *poutbuf = NULL; | |
6173 *poutbuf_size = 0; | |
6174 return buf_size; | |
6175 } | |
6176 | |
6177 *poutbuf = (uint8_t *)buf; | |
6178 *poutbuf_size = buf_size; | |
6179 return next; | |
6180 } | |
6181 | |
1168 | 6182 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
6183 MpegEncContext * const s = &h->s; | |
6184 AVCodecContext * const avctx= s->avctx; | |
6185 int buf_index=0; | |
1322 | 6186 #if 0 |
1168 | 6187 int i; |
6188 for(i=0; i<32; i++){ | |
6189 printf("%X ", buf[i]); | |
6190 } | |
6191 #endif | |
2392 | 6192 h->slice_num = 0; |
1168 | 6193 for(;;){ |
6194 int consumed; | |
6195 int dst_length; | |
6196 int bit_length; | |
6197 uint8_t *ptr; | |
2227 | 6198 int i, nalsize = 0; |
1168 | 6199 |
2227 | 6200 if(h->is_avc) { |
6201 if(buf_index >= buf_size) break; | |
6202 nalsize = 0; | |
6203 for(i = 0; i < h->nal_length_size; i++) | |
6204 nalsize = (nalsize << 8) | buf[buf_index++]; | |
6205 } else { | |
1168 | 6206 // start code prefix search |
6207 for(; buf_index + 3 < buf_size; buf_index++){ | |
6208 // this should allways succeed in the first iteration | |
6209 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
6210 break; | |
6211 } | |
6212 | |
6213 if(buf_index+3 >= buf_size) break; | |
6214 | |
6215 buf_index+=3; | |
2227 | 6216 } |
1168 | 6217 |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
6218 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
1168 | 6219 if(ptr[dst_length - 1] == 0) dst_length--; |
6220 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); | |
6221 | |
6222 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
6223 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 | 6224 } |
6225 | |
2227 | 6226 if (h->is_avc && (nalsize != consumed)) |
6227 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
6228 | |
1168 | 6229 buf_index += consumed; |
6230 | |
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
|
6231 if( s->hurry_up == 1 && h->nal_ref_idc == 0 ) |
1168 | 6232 continue; |
6233 | |
6234 switch(h->nal_unit_type){ | |
6235 case NAL_IDR_SLICE: | |
6236 idr(h); //FIXME ensure we dont loose some frames if there is reordering | |
6237 case NAL_SLICE: | |
6238 init_get_bits(&s->gb, ptr, bit_length); | |
6239 h->intra_gb_ptr= | |
6240 h->inter_gb_ptr= &s->gb; | |
6241 s->data_partitioning = 0; | |
6242 | |
6243 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
|
6244 if(h->redundant_pic_count==0 && s->hurry_up < 5 ) |
1168 | 6245 decode_slice(h); |
6246 break; | |
6247 case NAL_DPA: | |
6248 init_get_bits(&s->gb, ptr, bit_length); | |
6249 h->intra_gb_ptr= | |
6250 h->inter_gb_ptr= NULL; | |
6251 s->data_partitioning = 1; | |
6252 | |
6253 if(decode_slice_header(h) < 0) return -1; | |
6254 break; | |
6255 case NAL_DPB: | |
6256 init_get_bits(&h->intra_gb, ptr, bit_length); | |
6257 h->intra_gb_ptr= &h->intra_gb; | |
6258 break; | |
6259 case NAL_DPC: | |
6260 init_get_bits(&h->inter_gb, ptr, bit_length); | |
6261 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 6262 |
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
|
6263 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning && s->hurry_up < 5 ) |
1168 | 6264 decode_slice(h); |
6265 break; | |
6266 case NAL_SEI: | |
6267 break; | |
6268 case NAL_SPS: | |
6269 init_get_bits(&s->gb, ptr, bit_length); | |
6270 decode_seq_parameter_set(h); | |
6271 | |
6272 if(s->flags& CODEC_FLAG_LOW_DELAY) | |
6273 s->low_delay=1; | |
6274 | |
6275 avctx->has_b_frames= !s->low_delay; | |
6276 break; | |
6277 case NAL_PPS: | |
6278 init_get_bits(&s->gb, ptr, bit_length); | |
6279 | |
6280 decode_picture_parameter_set(h); | |
6281 | |
6282 break; | |
6283 case NAL_PICTURE_DELIMITER: | |
6284 break; | |
6285 case NAL_FILTER_DATA: | |
6286 break; | |
2099 | 6287 default: |
6288 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
1168 | 6289 } |
6290 | |
6291 //FIXME move after where irt is set | |
6292 s->current_picture.pict_type= s->pict_type; | |
6293 s->current_picture.key_frame= s->pict_type == I_TYPE; | |
6294 } | |
6295 | |
1174 | 6296 if(!s->current_picture_ptr) return buf_index; //no frame |
6297 | |
1168 | 6298 h->prev_frame_num_offset= h->frame_num_offset; |
6299 h->prev_frame_num= h->frame_num; | |
6300 if(s->current_picture_ptr->reference){ | |
6301 h->prev_poc_msb= h->poc_msb; | |
6302 h->prev_poc_lsb= h->poc_lsb; | |
6303 } | |
6304 if(s->current_picture_ptr->reference) | |
6305 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
6306 | |
6307 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
|
6308 |
1168 | 6309 MPV_frame_end(s); |
6310 | |
6311 return buf_index; | |
6312 } | |
6313 | |
6314 /** | |
6315 * retunrs the number of bytes consumed for building the current frame | |
6316 */ | |
6317 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
6318 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
6319 pos -= s->parse_context.last_index; | |
6320 if(pos<0) pos=0; // FIXME remove (uneeded?) | |
6321 | |
6322 return pos; | |
6323 }else{ | |
6324 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
6325 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
6326 | |
6327 return pos; | |
6328 } | |
6329 } | |
6330 | |
6331 static int decode_frame(AVCodecContext *avctx, | |
6332 void *data, int *data_size, | |
6333 uint8_t *buf, int buf_size) | |
6334 { | |
6335 H264Context *h = avctx->priv_data; | |
6336 MpegEncContext *s = &h->s; | |
6337 AVFrame *pict = data; | |
6338 int buf_index; | |
6339 | |
6340 s->flags= avctx->flags; | |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
6341 s->flags2= avctx->flags2; |
1168 | 6342 |
6343 /* no supplementary picture */ | |
6344 if (buf_size == 0) { | |
6345 return 0; | |
6346 } | |
6347 | |
6348 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
2392 | 6349 int next= find_frame_end(h, buf, buf_size); |
1168 | 6350 |
1988 | 6351 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 6352 return buf_size; |
6353 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
6354 } | |
6355 | |
2227 | 6356 if(h->is_avc && !h->got_avcC) { |
6357 int i, cnt, nalsize; | |
6358 unsigned char *p = avctx->extradata; | |
6359 if(avctx->extradata_size < 7) { | |
6360 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
6361 return -1; | |
6362 } | |
6363 if(*p != 1) { | |
6364 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
6365 return -1; | |
6366 } | |
6367 /* sps and pps in the avcC always have length coded with 2 bytes, | |
6368 so put a fake nal_length_size = 2 while parsing them */ | |
6369 h->nal_length_size = 2; | |
6370 // Decode sps from avcC | |
6371 cnt = *(p+5) & 0x1f; // Number of sps | |
6372 p += 6; | |
6373 for (i = 0; i < cnt; i++) { | |
6374 nalsize = BE_16(p) + 2; | |
6375 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
6376 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); | |
6377 return -1; | |
6378 } | |
6379 p += nalsize; | |
6380 } | |
6381 // Decode pps from avcC | |
6382 cnt = *(p++); // Number of pps | |
6383 for (i = 0; i < cnt; i++) { | |
6384 nalsize = BE_16(p) + 2; | |
6385 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
6386 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
6387 return -1; | |
6388 } | |
6389 p += nalsize; | |
6390 } | |
6391 // Now store right nal length size, that will be use to parse all other nals | |
6392 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
6393 // Do not reparse avcC | |
6394 h->got_avcC = 1; | |
6395 } | |
6396 | |
6397 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){ | |
1168 | 6398 if(0 < decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) ) |
6399 return -1; | |
6400 } | |
6401 | |
6402 buf_index=decode_nal_units(h, buf, buf_size); | |
6403 if(buf_index < 0) | |
6404 return -1; | |
6405 | |
6406 //FIXME do something with unavailable reference frames | |
6407 | |
6408 // if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_index, buf_size); | |
1174 | 6409 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6410 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 6411 return -1; |
6412 } | |
6413 | |
2409 | 6414 { |
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
|
6415 //#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
|
6416 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
|
6417 #ifndef DECODE_ORDER |
2409 | 6418 /* Sort B-frames into display order |
6419 * FIXME doesn't allow for multiple delayed frames */ | |
6420 Picture *cur = s->current_picture_ptr; | |
6421 Picture *prev = h->delayed_pic[0]; | |
6422 | |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6423 if(s->low_delay |
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6424 && (cur->pict_type == B_TYPE |
2409 | 6425 || (!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
|
6426 && prev && cur->poc - prev->poc > 2))){ |
2409 | 6427 s->low_delay = 0; |
6428 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
|
6429 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
|
6430 // 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
|
6431 cur = prev; |
2409 | 6432 } |
6433 | |
6434 if(s->low_delay || !prev || cur->pict_type == B_TYPE) | |
6435 out = cur; | |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6436 else |
2409 | 6437 out = prev; |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6438 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
|
6439 if(prev && prev->reference == 1) |
2409 | 6440 prev->reference = 0; |
2410
9d780478f8a5
reduce stutter if we learn too late that the stream contains B-frames.
lorenm
parents:
2409
diff
changeset
|
6441 h->delayed_pic[0] = cur; |
2409 | 6442 } |
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
|
6443 #endif |
2409 | 6444 |
6445 *pict= *(AVFrame*)out; | |
6446 } | |
6447 | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1698
diff
changeset
|
6448 ff_print_debug_info(s, pict); |
1168 | 6449 assert(pict->data[0]); |
6450 //printf("out %d\n", (int)pict->data[0]); | |
6451 #if 0 //? | |
6452 | |
6453 /* Return the Picture timestamp as the frame number */ | |
6454 /* we substract 1 because it is added on utils.c */ | |
6455 avctx->frame_number = s->picture_number - 1; | |
6456 #endif | |
6457 #if 0 | |
6458 /* dont output the last pic after seeking */ | |
6459 if(s->last_picture_ptr || s->low_delay) | |
2392 | 6460 //Note this isnt a issue as a IDR pic should flush the buffers |
1168 | 6461 #endif |
6462 *data_size = sizeof(AVFrame); | |
6463 return get_consumed_bytes(s, buf_index, buf_size); | |
6464 } | |
6465 #if 0 | |
6466 static inline void fill_mb_avail(H264Context *h){ | |
6467 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
|
6468 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 6469 |
6470 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
|
6471 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
|
6472 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
|
6473 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 6474 }else{ |
6475 h->mb_avail[0]= | |
6476 h->mb_avail[1]= | |
6477 h->mb_avail[2]= 0; | |
6478 } | |
6479 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
6480 h->mb_avail[4]= 1; //FIXME move out | |
6481 h->mb_avail[5]= 0; //FIXME move out | |
6482 } | |
6483 #endif | |
6484 | |
6485 #if 0 //selftest | |
6486 #define COUNT 8000 | |
6487 #define SIZE (COUNT*40) | |
6488 int main(){ | |
6489 int i; | |
6490 uint8_t temp[SIZE]; | |
6491 PutBitContext pb; | |
6492 GetBitContext gb; | |
6493 // int int_temp[10000]; | |
6494 DSPContext dsp; | |
6495 AVCodecContext avctx; | |
6496 | |
6497 dsputil_init(&dsp, &avctx); | |
6498 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
6499 init_put_bits(&pb, temp, SIZE); |
1168 | 6500 printf("testing unsigned exp golomb\n"); |
6501 for(i=0; i<COUNT; i++){ | |
6502 START_TIMER | |
6503 set_ue_golomb(&pb, i); | |
6504 STOP_TIMER("set_ue_golomb"); | |
6505 } | |
6506 flush_put_bits(&pb); | |
6507 | |
6508 init_get_bits(&gb, temp, 8*SIZE); | |
6509 for(i=0; i<COUNT; i++){ | |
6510 int j, s; | |
6511 | |
6512 s= show_bits(&gb, 24); | |
6513 | |
6514 START_TIMER | |
6515 j= get_ue_golomb(&gb); | |
6516 if(j != i){ | |
6517 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
6518 // return -1; | |
6519 } | |
6520 STOP_TIMER("get_ue_golomb"); | |
6521 } | |
6522 | |
6523 | |
1524 | 6524 init_put_bits(&pb, temp, SIZE); |
1168 | 6525 printf("testing signed exp golomb\n"); |
6526 for(i=0; i<COUNT; i++){ | |
6527 START_TIMER | |
6528 set_se_golomb(&pb, i - COUNT/2); | |
6529 STOP_TIMER("set_se_golomb"); | |
6530 } | |
6531 flush_put_bits(&pb); | |
6532 | |
6533 init_get_bits(&gb, temp, 8*SIZE); | |
6534 for(i=0; i<COUNT; i++){ | |
6535 int j, s; | |
6536 | |
6537 s= show_bits(&gb, 24); | |
6538 | |
6539 START_TIMER | |
6540 j= get_se_golomb(&gb); | |
6541 if(j != i - COUNT/2){ | |
6542 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
6543 // return -1; | |
6544 } | |
6545 STOP_TIMER("get_se_golomb"); | |
6546 } | |
6547 | |
6548 printf("testing 4x4 (I)DCT\n"); | |
6549 | |
6550 DCTELEM block[16]; | |
6551 uint8_t src[16], ref[16]; | |
6552 uint64_t error= 0, max_error=0; | |
6553 | |
6554 for(i=0; i<COUNT; i++){ | |
6555 int j; | |
6556 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
6557 for(j=0; j<16; j++){ | |
6558 ref[j]= random()%255; | |
6559 src[j]= random()%255; | |
6560 } | |
6561 | |
6562 h264_diff_dct_c(block, src, ref, 4); | |
6563 | |
6564 //normalize | |
6565 for(j=0; j<16; j++){ | |
6566 // printf("%d ", block[j]); | |
6567 block[j]= block[j]*4; | |
6568 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
6569 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
6570 } | |
6571 // printf("\n"); | |
6572 | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
6573 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 6574 /* for(j=0; j<16; j++){ |
6575 printf("%d ", ref[j]); | |
6576 } | |
6577 printf("\n");*/ | |
6578 | |
6579 for(j=0; j<16; j++){ | |
6580 int diff= ABS(src[j] - ref[j]); | |
6581 | |
6582 error+= diff*diff; | |
6583 max_error= FFMAX(max_error, diff); | |
6584 } | |
6585 } | |
6586 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
6587 #if 0 | |
6588 printf("testing quantizer\n"); | |
6589 for(qp=0; qp<52; qp++){ | |
6590 for(i=0; i<16; i++) | |
6591 src1_block[i]= src2_block[i]= random()%255; | |
6592 | |
6593 } | |
6594 #endif | |
6595 printf("Testing NAL layer\n"); | |
6596 | |
6597 uint8_t bitstream[COUNT]; | |
6598 uint8_t nal[COUNT*2]; | |
6599 H264Context h; | |
6600 memset(&h, 0, sizeof(H264Context)); | |
6601 | |
6602 for(i=0; i<COUNT; i++){ | |
6603 int zeros= i; | |
6604 int nal_length; | |
6605 int consumed; | |
6606 int out_length; | |
6607 uint8_t *out; | |
6608 int j; | |
6609 | |
6610 for(j=0; j<COUNT; j++){ | |
6611 bitstream[j]= (random() % 255) + 1; | |
6612 } | |
6613 | |
6614 for(j=0; j<zeros; j++){ | |
6615 int pos= random() % COUNT; | |
6616 while(bitstream[pos] == 0){ | |
6617 pos++; | |
6618 pos %= COUNT; | |
6619 } | |
6620 bitstream[pos]=0; | |
6621 } | |
6622 | |
6623 START_TIMER | |
6624 | |
6625 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); | |
6626 if(nal_length<0){ | |
6627 printf("encoding failed\n"); | |
6628 return -1; | |
6629 } | |
6630 | |
6631 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); | |
6632 | |
6633 STOP_TIMER("NAL") | |
6634 | |
6635 if(out_length != COUNT){ | |
6636 printf("incorrect length %d %d\n", out_length, COUNT); | |
6637 return -1; | |
6638 } | |
6639 | |
6640 if(consumed != nal_length){ | |
6641 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
6642 return -1; | |
6643 } | |
6644 | |
6645 if(memcmp(bitstream, out, COUNT)){ | |
6646 printf("missmatch\n"); | |
6647 return -1; | |
6648 } | |
6649 } | |
6650 | |
6651 printf("Testing RBSP\n"); | |
6652 | |
6653 | |
6654 return 0; | |
6655 } | |
6656 #endif | |
6657 | |
6658 | |
6659 static int decode_end(AVCodecContext *avctx) | |
6660 { | |
6661 H264Context *h = avctx->priv_data; | |
6662 MpegEncContext *s = &h->s; | |
6663 | |
6664 free_tables(h); //FIXME cleanup init stuff perhaps | |
6665 MPV_common_end(s); | |
6666 | |
6667 // memset(h, 0, sizeof(H264Context)); | |
6668 | |
6669 return 0; | |
6670 } | |
6671 | |
6672 | |
6673 AVCodec h264_decoder = { | |
6674 "h264", | |
6675 CODEC_TYPE_VIDEO, | |
6676 CODEC_ID_H264, | |
6677 sizeof(H264Context), | |
6678 decode_init, | |
6679 NULL, | |
6680 decode_end, | |
6681 decode_frame, | |
2453 | 6682 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1168 | 6683 }; |
6684 | |
1988 | 6685 AVCodecParser h264_parser = { |
6686 { CODEC_ID_H264 }, | |
2392 | 6687 sizeof(H264Context), |
1988 | 6688 NULL, |
6689 h264_parse, | |
6690 ff_parse_close, | |
6691 }; | |
6692 | |
1234 | 6693 #include "svq3.c" |