fc689988abb9c10d20ccbbb55545b6d940b1355c
[libav.git] / libavcodec / h264.c
1 /*
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file h264.c
24 * H.264 / AVC / MPEG4 part10 codec.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28 #include "dsputil.h"
29 #include "avcodec.h"
30 #include "mpegvideo.h"
31 #include "h264.h"
32 #include "h264data.h"
33 #include "h264_parser.h"
34 #include "golomb.h"
35 #include "rectangle.h"
36
37 #include "cabac.h"
38 #ifdef ARCH_X86
39 #include "x86/h264_i386.h"
40 #endif
41
42 //#undef NDEBUG
43 #include <assert.h>
44
45 /**
46 * Value of Picture.reference when Picture is not a reference picture, but
47 * is held for delayed output.
48 */
49 #define DELAYED_PIC_REF 4
50
51 static VLC coeff_token_vlc[4];
52 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
53 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
54
55 static VLC chroma_dc_coeff_token_vlc;
56 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
57 static const int chroma_dc_coeff_token_vlc_table_size = 256;
58
59 static VLC total_zeros_vlc[15];
60 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
61 static const int total_zeros_vlc_tables_size = 512;
62
63 static VLC chroma_dc_total_zeros_vlc[3];
64 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
65 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
66
67 static VLC run_vlc[6];
68 static VLC_TYPE run_vlc_tables[6][8][2];
69 static const int run_vlc_tables_size = 8;
70
71 static VLC run7_vlc;
72 static VLC_TYPE run7_vlc_table[96][2];
73 static const int run7_vlc_table_size = 96;
74
75 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
76 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
77 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);
78 static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);
79 static Picture * remove_long(H264Context *h, int i, int ref_mask);
80
81 static av_always_inline uint32_t pack16to32(int a, int b){
82 #ifdef WORDS_BIGENDIAN
83 return (b&0xFFFF) + (a<<16);
84 #else
85 return (a&0xFFFF) + (b<<16);
86 #endif
87 }
88
89 static const uint8_t rem6[52]={
90 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
91 };
92
93 static const uint8_t div6[52]={
94 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
95 };
96
97 static const int left_block_options[4][8]={
98 {0,1,2,3,7,10,8,11},
99 {2,2,3,3,8,11,8,11},
100 {0,0,1,1,7,10,7,10},
101 {0,2,0,2,7,10,7,10}
102 };
103
104 #define LEVEL_TAB_BITS 8
105 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
106
107 static void fill_caches(H264Context *h, int mb_type, int for_deblock){
108 MpegEncContext * const s = &h->s;
109 const int mb_xy= h->mb_xy;
110 int topleft_xy, top_xy, topright_xy, left_xy[2];
111 int topleft_type, top_type, topright_type, left_type[2];
112 const int * left_block;
113 int topleft_partition= -1;
114 int i;
115
116 top_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
117
118 //FIXME deblocking could skip the intra and nnz parts.
119 if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF)
120 return;
121
122 /* Wow, what a mess, why didn't they simplify the interlacing & intra
123 * stuff, I can't imagine that these complex rules are worth it. */
124
125 topleft_xy = top_xy - 1;
126 topright_xy= top_xy + 1;
127 left_xy[1] = left_xy[0] = mb_xy-1;
128 left_block = left_block_options[0];
129 if(FRAME_MBAFF){
130 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
131 const int top_pair_xy = pair_xy - s->mb_stride;
132 const int topleft_pair_xy = top_pair_xy - 1;
133 const int topright_pair_xy = top_pair_xy + 1;
134 const int topleft_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
135 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
136 const int topright_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
137 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
138 const int curr_mb_field_flag = IS_INTERLACED(mb_type);
139 const int bottom = (s->mb_y & 1);
140 tprintf(s->avctx, "fill_caches: curr_mb_field_flag:%d, left_mb_field_flag:%d, topleft_mb_field_flag:%d, top_mb_field_flag:%d, topright_mb_field_flag:%d\n", curr_mb_field_flag, left_mb_field_flag, topleft_mb_field_flag, top_mb_field_flag, topright_mb_field_flag);
141
142 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
143 top_xy -= s->mb_stride;
144 }
145 if (curr_mb_field_flag && (bottom || topleft_mb_field_flag)){
146 topleft_xy -= s->mb_stride;
147 } else if(bottom && !curr_mb_field_flag && left_mb_field_flag) {
148 topleft_xy += s->mb_stride;
149 // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition
150 topleft_partition = 0;
151 }
152 if (curr_mb_field_flag && (bottom || topright_mb_field_flag)){
153 topright_xy -= s->mb_stride;
154 }
155 if (left_mb_field_flag != curr_mb_field_flag) {
156 left_xy[1] = left_xy[0] = pair_xy - 1;
157 if (curr_mb_field_flag) {
158 left_xy[1] += s->mb_stride;
159 left_block = left_block_options[3];
160 } else {
161 left_block= left_block_options[2 - bottom];
162 }
163 }
164 }
165
166 h->top_mb_xy = top_xy;
167 h->left_mb_xy[0] = left_xy[0];
168 h->left_mb_xy[1] = left_xy[1];
169 if(for_deblock){
170 topleft_type = 0;
171 topright_type = 0;
172 top_type = h->slice_table[top_xy ] < 0xFFFF ? s->current_picture.mb_type[top_xy] : 0;
173 left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;
174 left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;
175
176 if(MB_MBAFF && !IS_INTRA(mb_type)){
177 int list;
178 for(list=0; list<h->list_count; list++){
179 //These values where changed for ease of performing MC, we need to change them back
180 //FIXME maybe we can make MC and loop filter use the same values or prevent
181 //the MC code from changing ref_cache and rather use a temporary array.
182 if(USES_LIST(mb_type,list)){
183 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];
184 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
185 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;
186 ref += h->b8_stride;
187 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
188 *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;
189 }
190 }
191 }
192 }else{
193 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
194 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
195 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
196 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
197 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
198
199 if(IS_INTRA(mb_type)){
200 int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
201 h->topleft_samples_available=
202 h->top_samples_available=
203 h->left_samples_available= 0xFFFF;
204 h->topright_samples_available= 0xEEEA;
205
206 if(!(top_type & type_mask)){
207 h->topleft_samples_available= 0xB3FF;
208 h->top_samples_available= 0x33FF;
209 h->topright_samples_available= 0x26EA;
210 }
211 if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){
212 if(IS_INTERLACED(mb_type)){
213 if(!(left_type[0] & type_mask)){
214 h->topleft_samples_available&= 0xDFFF;
215 h->left_samples_available&= 0x5FFF;
216 }
217 if(!(left_type[1] & type_mask)){
218 h->topleft_samples_available&= 0xFF5F;
219 h->left_samples_available&= 0xFF5F;
220 }
221 }else{
222 int left_typei = h->slice_table[left_xy[0] + s->mb_stride ] == h->slice_num
223 ? s->current_picture.mb_type[left_xy[0] + s->mb_stride] : 0;
224 assert(left_xy[0] == left_xy[1]);
225 if(!((left_typei & type_mask) && (left_type[0] & type_mask))){
226 h->topleft_samples_available&= 0xDF5F;
227 h->left_samples_available&= 0x5F5F;
228 }
229 }
230 }else{
231 if(!(left_type[0] & type_mask)){
232 h->topleft_samples_available&= 0xDF5F;
233 h->left_samples_available&= 0x5F5F;
234 }
235 }
236
237 if(!(topleft_type & type_mask))
238 h->topleft_samples_available&= 0x7FFF;
239
240 if(!(topright_type & type_mask))
241 h->topright_samples_available&= 0xFBFF;
242
243 if(IS_INTRA4x4(mb_type)){
244 if(IS_INTRA4x4(top_type)){
245 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
246 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
247 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
248 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
249 }else{
250 int pred;
251 if(!(top_type & type_mask))
252 pred= -1;
253 else{
254 pred= 2;
255 }
256 h->intra4x4_pred_mode_cache[4+8*0]=
257 h->intra4x4_pred_mode_cache[5+8*0]=
258 h->intra4x4_pred_mode_cache[6+8*0]=
259 h->intra4x4_pred_mode_cache[7+8*0]= pred;
260 }
261 for(i=0; i<2; i++){
262 if(IS_INTRA4x4(left_type[i])){
263 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
264 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
265 }else{
266 int pred;
267 if(!(left_type[i] & type_mask))
268 pred= -1;
269 else{
270 pred= 2;
271 }
272 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
273 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
274 }
275 }
276 }
277 }
278 }
279
280
281 /*
282 0 . T T. T T T T
283 1 L . .L . . . .
284 2 L . .L . . . .
285 3 . T TL . . . .
286 4 L . .L . . . .
287 5 L . .. . . . .
288 */
289 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
290 if(top_type){
291 h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];
292 h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];
293 h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];
294 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
295
296 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];
297 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
298
299 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];
300 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
301
302 }else{
303 h->non_zero_count_cache[4+8*0]=
304 h->non_zero_count_cache[5+8*0]=
305 h->non_zero_count_cache[6+8*0]=
306 h->non_zero_count_cache[7+8*0]=
307
308 h->non_zero_count_cache[1+8*0]=
309 h->non_zero_count_cache[2+8*0]=
310
311 h->non_zero_count_cache[1+8*3]=
312 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
313
314 }
315
316 for (i=0; i<2; i++) {
317 if(left_type[i]){
318 h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];
319 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];
320 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];
321 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];
322 }else{
323 h->non_zero_count_cache[3+8*1 + 2*8*i]=
324 h->non_zero_count_cache[3+8*2 + 2*8*i]=
325 h->non_zero_count_cache[0+8*1 + 8*i]=
326 h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
327 }
328 }
329
330 if( h->pps.cabac ) {
331 // top_cbp
332 if(top_type) {
333 h->top_cbp = h->cbp_table[top_xy];
334 } else if(IS_INTRA(mb_type)) {
335 h->top_cbp = 0x1C0;
336 } else {
337 h->top_cbp = 0;
338 }
339 // left_cbp
340 if (left_type[0]) {
341 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
342 } else if(IS_INTRA(mb_type)) {
343 h->left_cbp = 0x1C0;
344 } else {
345 h->left_cbp = 0;
346 }
347 if (left_type[0]) {
348 h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;
349 }
350 if (left_type[1]) {
351 h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;
352 }
353 }
354
355 #if 1
356 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
357 int list;
358 for(list=0; list<h->list_count; list++){
359 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){
360 /*if(!h->mv_cache_clean[list]){
361 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
362 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
363 h->mv_cache_clean[list]= 1;
364 }*/
365 continue;
366 }
367 h->mv_cache_clean[list]= 0;
368
369 if(USES_LIST(top_type, list)){
370 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
371 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
372 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
373 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
374 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
375 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
376 h->ref_cache[list][scan8[0] + 0 - 1*8]=
377 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
378 h->ref_cache[list][scan8[0] + 2 - 1*8]=
379 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
380 }else{
381 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=
382 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=
383 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=
384 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
385 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
386 }
387
388 for(i=0; i<2; i++){
389 int cache_idx = scan8[0] - 1 + i*2*8;
390 if(USES_LIST(left_type[i], list)){
391 const int b_xy= h->mb2b_xy[left_xy[i]] + 3;
392 const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1;
393 *(uint32_t*)h->mv_cache[list][cache_idx ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]];
394 *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]];
395 h->ref_cache[list][cache_idx ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)];
396 h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)];
397 }else{
398 *(uint32_t*)h->mv_cache [list][cache_idx ]=
399 *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0;
400 h->ref_cache[list][cache_idx ]=
401 h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
402 }
403 }
404
405 if(for_deblock || ((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF))
406 continue;
407
408 if(USES_LIST(topleft_type, list)){
409 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + h->b_stride + (topleft_partition & 2*h->b_stride);
410 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (topleft_partition & h->b8_stride);
411 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
412 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
413 }else{
414 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
415 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
416 }
417
418 if(USES_LIST(topright_type, list)){
419 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
420 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
421 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
422 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
423 }else{
424 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
425 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
426 }
427
428 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)
429 continue;
430
431 h->ref_cache[list][scan8[5 ]+1] =
432 h->ref_cache[list][scan8[7 ]+1] =
433 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else)
434 h->ref_cache[list][scan8[4 ]] =
435 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
436 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
437 *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
438 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
439 *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
440 *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
441
442 if( h->pps.cabac ) {
443 /* XXX beurk, Load mvd */
444 if(USES_LIST(top_type, list)){
445 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
446 *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];
447 *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];
448 *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];
449 *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];
450 }else{
451 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=
452 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=
453 *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=
454 *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;
455 }
456 if(USES_LIST(left_type[0], list)){
457 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
458 *(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]];
459 *(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]];
460 }else{
461 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=
462 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;
463 }
464 if(USES_LIST(left_type[1], list)){
465 const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
466 *(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]];
467 *(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]];
468 }else{
469 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=
470 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;
471 }
472 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=
473 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=
474 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
475 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=
476 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;
477
478 if(h->slice_type_nos == FF_B_TYPE){
479 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);
480
481 if(IS_DIRECT(top_type)){
482 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;
483 }else if(IS_8X8(top_type)){
484 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;
485 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];
486 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];
487 }else{
488 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;
489 }
490
491 if(IS_DIRECT(left_type[0]))
492 h->direct_cache[scan8[0] - 1 + 0*8]= 1;
493 else if(IS_8X8(left_type[0]))
494 h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)];
495 else
496 h->direct_cache[scan8[0] - 1 + 0*8]= 0;
497
498 if(IS_DIRECT(left_type[1]))
499 h->direct_cache[scan8[0] - 1 + 2*8]= 1;
500 else if(IS_8X8(left_type[1]))
501 h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)];
502 else
503 h->direct_cache[scan8[0] - 1 + 2*8]= 0;
504 }
505 }
506
507 if(FRAME_MBAFF){
508 #define MAP_MVS\
509 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\
510 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\
511 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\
512 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\
513 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\
514 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\
515 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\
516 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\
517 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\
518 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])
519 if(MB_FIELD){
520 #define MAP_F2F(idx, mb_type)\
521 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
522 h->ref_cache[list][idx] <<= 1;\
523 h->mv_cache[list][idx][1] /= 2;\
524 h->mvd_cache[list][idx][1] /= 2;\
525 }
526 MAP_MVS
527 #undef MAP_F2F
528 }else{
529 #define MAP_F2F(idx, mb_type)\
530 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
531 h->ref_cache[list][idx] >>= 1;\
532 h->mv_cache[list][idx][1] <<= 1;\
533 h->mvd_cache[list][idx][1] <<= 1;\
534 }
535 MAP_MVS
536 #undef MAP_F2F
537 }
538 }
539 }
540 }
541 #endif
542
543 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
544 }
545
546 static inline void write_back_intra_pred_mode(H264Context *h){
547 const int mb_xy= h->mb_xy;
548
549 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
550 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
551 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
552 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
553 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
554 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
555 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
556 }
557
558 /**
559 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
560 */
561 static inline int check_intra4x4_pred_mode(H264Context *h){
562 MpegEncContext * const s = &h->s;
563 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
564 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
565 int i;
566
567 if(!(h->top_samples_available&0x8000)){
568 for(i=0; i<4; i++){
569 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
570 if(status<0){
571 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);
572 return -1;
573 } else if(status){
574 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
575 }
576 }
577 }
578
579 if((h->left_samples_available&0x8888)!=0x8888){
580 static const int mask[4]={0x8000,0x2000,0x80,0x20};
581 for(i=0; i<4; i++){
582 if(!(h->left_samples_available&mask[i])){
583 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
584 if(status<0){
585 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);
586 return -1;
587 } else if(status){
588 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
589 }
590 }
591 }
592 }
593
594 return 0;
595 } //FIXME cleanup like next
596
597 /**
598 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
599 */
600 static inline int check_intra_pred_mode(H264Context *h, int mode){
601 MpegEncContext * const s = &h->s;
602 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
603 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
604
605 if(mode > 6U) {
606 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);
607 return -1;
608 }
609
610 if(!(h->top_samples_available&0x8000)){
611 mode= top[ mode ];
612 if(mode<0){
613 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);
614 return -1;
615 }
616 }
617
618 if((h->left_samples_available&0x8080) != 0x8080){
619 mode= left[ mode ];
620 if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
621 mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
622 }
623 if(mode<0){
624 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);
625 return -1;
626 }
627 }
628
629 return mode;
630 }
631
632 /**
633 * gets the predicted intra4x4 prediction mode.
634 */
635 static inline int pred_intra_mode(H264Context *h, int n){
636 const int index8= scan8[n];
637 const int left= h->intra4x4_pred_mode_cache[index8 - 1];
638 const int top = h->intra4x4_pred_mode_cache[index8 - 8];
639 const int min= FFMIN(left, top);
640
641 tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min);
642
643 if(min<0) return DC_PRED;
644 else return min;
645 }
646
647 static inline void write_back_non_zero_count(H264Context *h){
648 const int mb_xy= h->mb_xy;
649
650 h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];
651 h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];
652 h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];
653 h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
654 h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];
655 h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];
656 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];
657
658 h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];
659 h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
660 h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];
661
662 h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];
663 h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
664 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];
665 }
666
667 /**
668 * gets the predicted number of non-zero coefficients.
669 * @param n block index
670 */
671 static inline int pred_non_zero_count(H264Context *h, int n){
672 const int index8= scan8[n];
673 const int left= h->non_zero_count_cache[index8 - 1];
674 const int top = h->non_zero_count_cache[index8 - 8];
675 int i= left + top;
676
677 if(i<64) i= (i+1)>>1;
678
679 tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
680
681 return i&31;
682 }
683
684 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
685 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
686 MpegEncContext *s = &h->s;
687
688 /* there is no consistent mapping of mvs to neighboring locations that will
689 * make mbaff happy, so we can't move all this logic to fill_caches */
690 if(FRAME_MBAFF){
691 const uint32_t *mb_types = s->current_picture_ptr->mb_type;
692 const int16_t *mv;
693 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;
694 *C = h->mv_cache[list][scan8[0]-2];
695
696 if(!MB_FIELD
697 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){
698 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);
699 if(IS_INTERLACED(mb_types[topright_xy])){
700 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\
701 const int x4 = X4, y4 = Y4;\
702 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\
703 if(!USES_LIST(mb_type,list))\
704 return LIST_NOT_USED;\
705 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\
706 h->mv_cache[list][scan8[0]-2][0] = mv[0];\
707 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
708 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;
709
710 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);
711 }
712 }
713 if(topright_ref == PART_NOT_AVAILABLE
714 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4
715 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
716 if(!MB_FIELD
717 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){
718 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);
719 }
720 if(MB_FIELD
721 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])
722 && i >= scan8[0]+8){
723 // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
724 SET_DIAG_MV(/2, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);
725 }
726 }
727 #undef SET_DIAG_MV
728 }
729
730 if(topright_ref != PART_NOT_AVAILABLE){
731 *C= h->mv_cache[list][ i - 8 + part_width ];
732 return topright_ref;
733 }else{
734 tprintf(s->avctx, "topright MV not available\n");
735
736 *C= h->mv_cache[list][ i - 8 - 1 ];
737 return h->ref_cache[list][ i - 8 - 1 ];
738 }
739 }
740
741 /**
742 * gets the predicted MV.
743 * @param n the block index
744 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
745 * @param mx the x component of the predicted motion vector
746 * @param my the y component of the predicted motion vector
747 */
748 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
749 const int index8= scan8[n];
750 const int top_ref= h->ref_cache[list][ index8 - 8 ];
751 const int left_ref= h->ref_cache[list][ index8 - 1 ];
752 const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
753 const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
754 const int16_t * C;
755 int diagonal_ref, match_count;
756
757 assert(part_width==1 || part_width==2 || part_width==4);
758
759 /* mv_cache
760 B . . A T T T T
761 U . . L . . , .
762 U . . L . . . .
763 U . . L . . , .
764 . . . L . . . .
765 */
766
767 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
768 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
769 tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count);
770 if(match_count > 1){ //most common
771 *mx= mid_pred(A[0], B[0], C[0]);
772 *my= mid_pred(A[1], B[1], C[1]);
773 }else if(match_count==1){
774 if(left_ref==ref){
775 *mx= A[0];
776 *my= A[1];
777 }else if(top_ref==ref){
778 *mx= B[0];
779 *my= B[1];
780 }else{
781 *mx= C[0];
782 *my= C[1];
783 }
784 }else{
785 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
786 *mx= A[0];
787 *my= A[1];
788 }else{
789 *mx= mid_pred(A[0], B[0], C[0]);
790 *my= mid_pred(A[1], B[1], C[1]);
791 }
792 }
793
794 tprintf(h->s.avctx, "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);
795 }
796
797 /**
798 * gets the directionally predicted 16x8 MV.
799 * @param n the block index
800 * @param mx the x component of the predicted motion vector
801 * @param my the y component of the predicted motion vector
802 */
803 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
804 if(n==0){
805 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ];
806 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
807
808 tprintf(h->s.avctx, "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);
809
810 if(top_ref == ref){
811 *mx= B[0];
812 *my= B[1];
813 return;
814 }
815 }else{
816 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ];
817 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
818
819 tprintf(h->s.avctx, "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);
820
821 if(left_ref == ref){
822 *mx= A[0];
823 *my= A[1];
824 return;
825 }
826 }
827
828 //RARE
829 pred_motion(h, n, 4, list, ref, mx, my);
830 }
831
832 /**
833 * gets the directionally predicted 8x16 MV.
834 * @param n the block index
835 * @param mx the x component of the predicted motion vector
836 * @param my the y component of the predicted motion vector
837 */
838 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
839 if(n==0){
840 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ];
841 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ];
842
843 tprintf(h->s.avctx, "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);
844
845 if(left_ref == ref){
846 *mx= A[0];
847 *my= A[1];
848 return;
849 }
850 }else{
851 const int16_t * C;
852 int diagonal_ref;
853
854 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
855
856 tprintf(h->s.avctx, "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);
857
858 if(diagonal_ref == ref){
859 *mx= C[0];
860 *my= C[1];
861 return;
862 }
863 }
864
865 //RARE
866 pred_motion(h, n, 2, list, ref, mx, my);
867 }
868
869 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
870 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
871 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
872
873 tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
874
875 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
876 || !( top_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ])
877 || !(left_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ])){
878
879 *mx = *my = 0;
880 return;
881 }
882
883 pred_motion(h, 0, 4, 0, 0, mx, my);
884
885 return;
886 }
887
888 static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){
889 int poc0 = h->ref_list[0][i].poc;
890 int td = av_clip(poc1 - poc0, -128, 127);
891 if(td == 0 || h->ref_list[0][i].long_ref){
892 return 256;
893 }else{
894 int tb = av_clip(poc - poc0, -128, 127);
895 int tx = (16384 + (FFABS(td) >> 1)) / td;
896 return av_clip((tb*tx + 32) >> 6, -1024, 1023);
897 }
898 }
899
900 static inline void direct_dist_scale_factor(H264Context * const h){
901 MpegEncContext * const s = &h->s;
902 const int poc = h->s.current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
903 const int poc1 = h->ref_list[1][0].poc;
904 int i, field;
905 for(field=0; field<2; field++){
906 const int poc = h->s.current_picture_ptr->field_poc[field];
907 const int poc1 = h->ref_list[1][0].field_poc[field];
908 for(i=0; i < 2*h->ref_count[0]; i++)
909 h->dist_scale_factor_field[field][i^field] = get_scale_factor(h, poc, poc1, i+16);
910 }
911
912 for(i=0; i<h->ref_count[0]; i++){
913 h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i);
914 }
915 }
916
917 static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){
918 MpegEncContext * const s = &h->s;
919 Picture * const ref1 = &h->ref_list[1][0];
920 int j, old_ref, rfield;
921 int start= mbafi ? 16 : 0;
922 int end = mbafi ? 16+2*h->ref_count[list] : h->ref_count[list];
923 int interl= mbafi || s->picture_structure != PICT_FRAME;
924
925 /* bogus; fills in for missing frames */
926 memset(map[list], 0, sizeof(map[list]));
927
928 for(rfield=0; rfield<2; rfield++){
929 for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){
930 int poc = ref1->ref_poc[colfield][list][old_ref];
931
932 if (!interl)
933 poc |= 3;
934 else if( interl && (poc&3) == 3) //FIXME store all MBAFF references so this isnt needed
935 poc= (poc&~3) + rfield + 1;
936
937 for(j=start; j<end; j++){
938 if(4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3) == poc){
939 int cur_ref= mbafi ? (j-16)^field : j;
940 map[list][2*old_ref + (rfield^field) + 16] = cur_ref;
941 if(rfield == field)
942 map[list][old_ref] = cur_ref;
943 break;
944 }
945 }
946 }
947 }
948 }
949
950 static inline void direct_ref_list_init(H264Context * const h){
951 MpegEncContext * const s = &h->s;
952 Picture * const ref1 = &h->ref_list[1][0];
953 Picture * const cur = s->current_picture_ptr;
954 int list, j, field;
955 int sidx= (s->picture_structure&1)^1;
956 int ref1sidx= (ref1->reference&1)^1;
957
958 for(list=0; list<2; list++){
959 cur->ref_count[sidx][list] = h->ref_count[list];
960 for(j=0; j<h->ref_count[list]; j++)
961 cur->ref_poc[sidx][list][j] = 4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3);
962 }
963
964 if(s->picture_structure == PICT_FRAME){
965 memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));
966 memcpy(cur->ref_poc [1], cur->ref_poc [0], sizeof(cur->ref_poc [0]));
967 }
968
969 cur->mbaff= FRAME_MBAFF;
970
971 if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)
972 return;
973
974 for(list=0; list<2; list++){
975 fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);
976 for(field=0; field<2; field++)
977 fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1);
978 }
979 }
980
981 static inline void pred_direct_motion(H264Context * const h, int *mb_type){
982 MpegEncContext * const s = &h->s;
983 int b8_stride = h->b8_stride;
984 int b4_stride = h->b_stride;
985 int mb_xy = h->mb_xy;
986 int mb_type_col[2];
987 const int16_t (*l1mv0)[2], (*l1mv1)[2];
988 const int8_t *l1ref0, *l1ref1;
989 const int is_b8x8 = IS_8X8(*mb_type);
990 unsigned int sub_mb_type;
991 int i8, i4;
992
993 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
994
995 if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL
996 if(!IS_INTERLACED(*mb_type)){ // AFR/FR -> AFL/FL
997 int cur_poc = s->current_picture_ptr->poc;
998 int *col_poc = h->ref_list[1]->field_poc;
999 int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);
1000 mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;
1001 b8_stride = 0;
1002 }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){// FL -> FL & differ parity
1003 int fieldoff= 2*(h->ref_list[1][0].reference)-3;
1004 mb_xy += s->mb_stride*fieldoff;
1005 }
1006 goto single_col;
1007 }else{ // AFL/AFR/FR/FL -> AFR/FR
1008 if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR
1009 mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;
1010 mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
1011 mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];
1012 b8_stride *= 3;
1013 b4_stride *= 6;
1014 //FIXME IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag
1015 if( (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)
1016 && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)
1017 && !is_b8x8){
1018 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1019 *mb_type |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */
1020 }else{
1021 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1022 *mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1;
1023 }
1024 }else{ // AFR/FR -> AFR/FR
1025 single_col:
1026 mb_type_col[0] =
1027 mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];
1028 if(IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag){
1029 /* FIXME save sub mb types from previous frames (or derive from MVs)
1030 * so we know exactly what block size to use */
1031 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
1032 *mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1;
1033 }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){
1034 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1035 *mb_type |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
1036 }else{
1037 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1038 *mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1;
1039 }
1040 }
1041 }
1042
1043 l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
1044 l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
1045 l1ref0 = &h->ref_list[1][0].ref_index [0][h->mb2b8_xy[mb_xy]];
1046 l1ref1 = &h->ref_list[1][0].ref_index [1][h->mb2b8_xy[mb_xy]];
1047 if(!b8_stride){
1048 if(s->mb_y&1){
1049 l1ref0 += h->b8_stride;
1050 l1ref1 += h->b8_stride;
1051 l1mv0 += 2*b4_stride;
1052 l1mv1 += 2*b4_stride;
1053 }
1054 }
1055
1056 if(h->direct_spatial_mv_pred){
1057 int ref[2];
1058 int mv[2][2];
1059 int list;
1060
1061 /* FIXME interlacing + spatial direct uses wrong colocated block positions */
1062
1063 /* ref = min(neighbors) */
1064 for(list=0; list<2; list++){
1065 int refa = h->ref_cache[list][scan8[0] - 1];
1066 int refb = h->ref_cache[list][scan8[0] - 8];
1067 int refc = h->ref_cache[list][scan8[0] - 8 + 4];
1068 if(refc == PART_NOT_AVAILABLE)
1069 refc = h->ref_cache[list][scan8[0] - 8 - 1];
1070 ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);
1071 if(ref[list] < 0)
1072 ref[list] = -1;
1073 }
1074
1075 if(ref[0] < 0 && ref[1] < 0){
1076 ref[0] = ref[1] = 0;
1077 mv[0][0] = mv[0][1] =
1078 mv[1][0] = mv[1][1] = 0;
1079 }else{
1080 for(list=0; list<2; list++){
1081 if(ref[list] >= 0)
1082 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
1083 else
1084 mv[list][0] = mv[list][1] = 0;
1085 }
1086 }
1087
1088 if(ref[1] < 0){
1089 if(!is_b8x8)
1090 *mb_type &= ~MB_TYPE_L1;
1091 sub_mb_type &= ~MB_TYPE_L1;
1092 }else if(ref[0] < 0){
1093 if(!is_b8x8)
1094 *mb_type &= ~MB_TYPE_L0;
1095 sub_mb_type &= ~MB_TYPE_L0;
1096 }
1097
1098 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
1099 for(i8=0; i8<4; i8++){
1100 int x8 = i8&1;
1101 int y8 = i8>>1;
1102 int xy8 = x8+y8*b8_stride;
1103 int xy4 = 3*x8+y8*b4_stride;
1104 int a=0, b=0;
1105
1106 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1107 continue;
1108 h->sub_mb_type[i8] = sub_mb_type;
1109
1110 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
1111 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
1112 if(!IS_INTRA(mb_type_col[y8])
1113 && ( (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)
1114 || (l1ref0[xy8] < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){
1115 if(ref[0] > 0)
1116 a= pack16to32(mv[0][0],mv[0][1]);
1117 if(ref[1] > 0)
1118 b= pack16to32(mv[1][0],mv[1][1]);
1119 }else{
1120 a= pack16to32(mv[0][0],mv[0][1]);
1121 b= pack16to32(mv[1][0],mv[1][1]);
1122 }
1123 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4);
1124 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);
1125 }
1126 }else if(IS_16X16(*mb_type)){
1127 int a=0, b=0;
1128
1129 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
1130 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
1131 if(!IS_INTRA(mb_type_col[0])
1132 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)
1133 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1
1134 && (h->x264_build>33 || !h->x264_build)))){
1135 if(ref[0] > 0)
1136 a= pack16to32(mv[0][0],mv[0][1]);
1137 if(ref[1] > 0)
1138 b= pack16to32(mv[1][0],mv[1][1]);
1139 }else{
1140 a= pack16to32(mv[0][0],mv[0][1]);
1141 b= pack16to32(mv[1][0],mv[1][1]);
1142 }
1143 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);
1144 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);
1145 }else{
1146 for(i8=0; i8<4; i8++){
1147 const int x8 = i8&1;
1148 const int y8 = i8>>1;
1149
1150 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1151 continue;
1152 h->sub_mb_type[i8] = sub_mb_type;
1153
1154 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1155 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1156 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
1157 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
1158
1159 /* col_zero_flag */
1160 if(!IS_INTRA(mb_type_col[0]) && ( l1ref0[x8 + y8*b8_stride] == 0
1161 || (l1ref0[x8 + y8*b8_stride] < 0 && l1ref1[x8 + y8*b8_stride] == 0
1162 && (h->x264_build>33 || !h->x264_build)))){
1163 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*b8_stride] == 0 ? l1mv0 : l1mv1;
1164 if(IS_SUB_8X8(sub_mb_type)){
1165 const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
1166 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
1167 if(ref[0] == 0)
1168 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1169 if(ref[1] == 0)
1170 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1171 }
1172 }else
1173 for(i4=0; i4<4; i4++){
1174 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
1175 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
1176 if(ref[0] == 0)
1177 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
1178 if(ref[1] == 0)
1179 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
1180 }
1181 }
1182 }
1183 }
1184 }
1185 }else{ /* direct temporal mv pred */
1186 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};
1187 const int *dist_scale_factor = h->dist_scale_factor;
1188 int ref_offset= 0;
1189
1190 if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){
1191 map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0];
1192 map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1];
1193 dist_scale_factor =h->dist_scale_factor_field[s->mb_y&1];
1194 }
1195 if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0]))
1196 ref_offset += 16;
1197
1198 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
1199 /* FIXME assumes direct_8x8_inference == 1 */
1200 int y_shift = 2*!IS_INTERLACED(*mb_type);
1201
1202 for(i8=0; i8<4; i8++){
1203 const int x8 = i8&1;
1204 const int y8 = i8>>1;
1205 int ref0, scale;
1206 const int16_t (*l1mv)[2]= l1mv0;
1207
1208 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1209 continue;
1210 h->sub_mb_type[i8] = sub_mb_type;
1211
1212 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1213 if(IS_INTRA(mb_type_col[y8])){
1214 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
1215 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1216 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1217 continue;
1218 }
1219
1220 ref0 = l1ref0[x8 + y8*b8_stride];
1221 if(ref0 >= 0)
1222 ref0 = map_col_to_list0[0][ref0 + ref_offset];
1223 else{
1224 ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];
1225 l1mv= l1mv1;
1226 }
1227 scale = dist_scale_factor[ref0];
1228 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
1229
1230 {
1231 const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride];
1232 int my_col = (mv_col[1]<<y_shift)/2;
1233 int mx = (scale * mv_col[0] + 128) >> 8;
1234 int my = (scale * my_col + 128) >> 8;
1235 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
1236 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);
1237 }
1238 }
1239 return;
1240 }
1241
1242 /* one-to-one mv scaling */
1243
1244 if(IS_16X16(*mb_type)){
1245 int ref, mv0, mv1;
1246
1247 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
1248 if(IS_INTRA(mb_type_col[0])){
1249 ref=mv0=mv1=0;
1250 }else{
1251 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]
1252 : map_col_to_list0[1][l1ref1[0] + ref_offset];
1253 const int scale = dist_scale_factor[ref0];
1254 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
1255 int mv_l0[2];
1256 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
1257 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
1258 ref= ref0;
1259 mv0= pack16to32(mv_l0[0],mv_l0[1]);
1260 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
1261 }
1262 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
1263 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);
1264 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);
1265 }else{
1266 for(i8=0; i8<4; i8++){
1267 const int x8 = i8&1;
1268 const int y8 = i8>>1;
1269 int ref0, scale;
1270 const int16_t (*l1mv)[2]= l1mv0;
1271
1272 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1273 continue;
1274 h->sub_mb_type[i8] = sub_mb_type;
1275 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1276 if(IS_INTRA(mb_type_col[0])){
1277 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
1278 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1279 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1280 continue;
1281 }
1282
1283 ref0 = l1ref0[x8 + y8*b8_stride] + ref_offset;
1284 if(ref0 >= 0)
1285 ref0 = map_col_to_list0[0][ref0];
1286 else{
1287 ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];
1288 l1mv= l1mv1;
1289 }
1290 scale = dist_scale_factor[ref0];
1291
1292 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
1293 if(IS_SUB_8X8(sub_mb_type)){
1294 const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
1295 int mx = (scale * mv_col[0] + 128) >> 8;
1296 int my = (scale * mv_col[1] + 128) >> 8;
1297 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
1298 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
1299 }else
1300 for(i4=0; i4<4; i4++){
1301 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
1302 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
1303 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
1304 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
1305 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
1306 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
1307 }
1308 }
1309 }
1310 }
1311 }
1312
1313 static inline void write_back_motion(H264Context *h, int mb_type){
1314 MpegEncContext * const s = &h->s;
1315 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
1316 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
1317 int list;
1318
1319 if(!USES_LIST(mb_type, 0))
1320 fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);
1321
1322 for(list=0; list<h->list_count; list++){
1323 int y;
1324 if(!USES_LIST(mb_type, list))
1325 continue;
1326
1327 for(y=0; y<4; y++){
1328 *(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];
1329 *(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];
1330 }
1331 if( h->pps.cabac ) {
1332 if(IS_SKIP(mb_type))
1333 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4);
1334 else
1335 for(y=0; y<4; y++){
1336 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];
1337 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];
1338 }
1339 }
1340
1341 {
1342 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];
1343 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];
1344 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];
1345 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];
1346 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];
1347 }
1348 }
1349
1350 if(h->slice_type_nos == FF_B_TYPE && h->pps.cabac){
1351 if(IS_8X8(mb_type)){
1352 uint8_t *direct_table = &h->direct_table[b8_xy];
1353 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;
1354 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;
1355 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;
1356 }
1357 }
1358 }
1359
1360 /**
1361 * Decodes a network abstraction layer unit.
1362 * @param consumed is the number of bytes used as input
1363 * @param length is the length of the array
1364 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
1365 * @returns decoded bytes, might be src+1 if no escapes
1366 */
1367 static const uint8_t *decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
1368 int i, si, di;
1369 uint8_t *dst;
1370 int bufidx;
1371
1372 // src[0]&0x80; //forbidden bit
1373 h->nal_ref_idc= src[0]>>5;
1374 h->nal_unit_type= src[0]&0x1F;
1375
1376 src++; length--;
1377 #if 0
1378 for(i=0; i<length; i++)
1379 printf("%2X ", src[i]);
1380 #endif
1381
1382 #ifdef HAVE_FAST_UNALIGNED
1383 # ifdef HAVE_FAST_64BIT
1384 # define RS 7
1385 for(i=0; i+1<length; i+=9){
1386 if(!((~*(uint64_t*)(src+i) & (*(uint64_t*)(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))
1387 # else
1388 # define RS 3
1389 for(i=0; i+1<length; i+=5){
1390 if(!((~*(uint32_t*)(src+i) & (*(uint32_t*)(src+i) - 0x01000101U)) & 0x80008080U))
1391 # endif
1392 continue;
1393 if(i>0 && !src[i]) i--;
1394 while(src[i]) i++;
1395 #else
1396 # define RS 0
1397 for(i=0; i+1<length; i+=2){
1398 if(src[i]) continue;
1399 if(i>0 && src[i-1]==0) i--;
1400 #endif
1401 if(i+2<length && src[i+1]==0 && src[i+2]<=3){
1402 if(src[i+2]!=3){
1403 /* startcode, so we must be past the end */
1404 length=i;
1405 }
1406 break;
1407 }
1408 i-= RS;
1409 }
1410
1411 if(i>=length-1){ //no escaped 0
1412 *dst_length= length;
1413 *consumed= length+1; //+1 for the header
1414 return src;
1415 }
1416
1417 bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
1418 h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
1419 dst= h->rbsp_buffer[bufidx];
1420
1421 if (dst == NULL){
1422 return NULL;
1423 }
1424
1425 //printf("decoding esc\n");
1426 memcpy(dst, src, i);
1427 si=di=i;
1428 while(si+2<length){
1429 //remove escapes (very rare 1:2^22)
1430 if(src[si+2]>3){
1431 dst[di++]= src[si++];
1432 dst[di++]= src[si++];
1433 }else if(src[si]==0 && src[si+1]==0){
1434 if(src[si+2]==3){ //escape
1435 dst[di++]= 0;
1436 dst[di++]= 0;
1437 si+=3;
1438 continue;
1439 }else //next start code
1440 goto nsc;
1441 }
1442
1443 dst[di++]= src[si++];
1444 }
1445 while(si<length)
1446 dst[di++]= src[si++];
1447 nsc:
1448
1449 memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1450
1451 *dst_length= di;
1452 *consumed= si + 1;//+1 for the header
1453 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
1454 return dst;
1455 }
1456
1457 /**
1458 * identifies the exact end of the bitstream
1459 * @return the length of the trailing, or 0 if damaged
1460 */
1461 static int decode_rbsp_trailing(H264Context *h, const uint8_t *src){
1462 int v= *src;
1463 int r;
1464
1465 tprintf(h->s.avctx, "rbsp trailing %X\n", v);
1466
1467 for(r=1; r<9; r++){
1468 if(v&1) return r;
1469 v>>=1;
1470 }
1471 return 0;
1472 }
1473
1474 /**
1475 * IDCT transforms the 16 dc values and dequantizes them.
1476 * @param qp quantization parameter
1477 */
1478 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1479 #define stride 16
1480 int i;
1481 int temp[16]; //FIXME check if this is a good idea
1482 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
1483 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1484
1485 //memset(block, 64, 2*256);
1486 //return;
1487 for(i=0; i<4; i++){
1488 const int offset= y_offset[i];
1489 const int z0= block[offset+stride*0] + block[offset+stride*4];
1490 const int z1= block[offset+stride*0] - block[offset+stride*4];
1491 const int z2= block[offset+stride*1] - block[offset+stride*5];
1492 const int z3= block[offset+stride*1] + block[offset+stride*5];
1493
1494 temp[4*i+0]= z0+z3;
1495 temp[4*i+1]= z1+z2;
1496 temp[4*i+2]= z1-z2;
1497 temp[4*i+3]= z0-z3;
1498 }
1499
1500 for(i=0; i<4; i++){
1501 const int offset= x_offset[i];
1502 const int z0= temp[4*0+i] + temp[4*2+i];
1503 const int z1= temp[4*0+i] - temp[4*2+i];
1504 const int z2= temp[4*1+i] - temp[4*3+i];
1505 const int z3= temp[4*1+i] + temp[4*3+i];
1506
1507 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual
1508 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
1509 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
1510 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
1511 }
1512 }
1513
1514 #if 0
1515 /**
1516 * DCT transforms the 16 dc values.
1517 * @param qp quantization parameter ??? FIXME
1518 */
1519 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
1520 // const int qmul= dequant_coeff[qp][0];
1521 int i;
1522 int temp[16]; //FIXME check if this is a good idea
1523 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
1524 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1525
1526 for(i=0; i<4; i++){
1527 const int offset= y_offset[i];
1528 const int z0= block[offset+stride*0] + block[offset+stride*4];
1529 const int z1= block[offset+stride*0] - block[offset+stride*4];
1530 const int z2= block[offset+stride*1] - block[offset+stride*5];
1531 const int z3= block[offset+stride*1] + block[offset+stride*5];
1532
1533 temp[4*i+0]= z0+z3;
1534 temp[4*i+1]= z1+z2;
1535 temp[4*i+2]= z1-z2;
1536 temp[4*i+3]= z0-z3;
1537 }
1538
1539 for(i=0; i<4; i++){
1540 const int offset= x_offset[i];
1541 const int z0= temp[4*0+i] + temp[4*2+i];
1542 const int z1= temp[4*0+i] - temp[4*2+i];
1543 const int z2= temp[4*1+i] - temp[4*3+i];
1544 const int z3= temp[4*1+i] + temp[4*3+i];
1545
1546 block[stride*0 +offset]= (z0 + z3)>>1;
1547 block[stride*2 +offset]= (z1 + z2)>>1;
1548 block[stride*8 +offset]= (z1 - z2)>>1;
1549 block[stride*10+offset]= (z0 - z3)>>1;
1550 }
1551 }
1552 #endif
1553
1554 #undef xStride
1555 #undef stride
1556
1557 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1558 const int stride= 16*2;
1559 const int xStride= 16;
1560 int a,b,c,d,e;
1561
1562 a= block[stride*0 + xStride*0];
1563 b= block[stride*0 + xStride*1];
1564 c= block[stride*1 + xStride*0];
1565 d= block[stride*1 + xStride*1];
1566
1567 e= a-b;
1568 a= a+b;
1569 b= c-d;
1570 c= c+d;
1571
1572 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
1573 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
1574 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
1575 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
1576 }
1577
1578 #if 0
1579 static void chroma_dc_dct_c(DCTELEM *block){
1580 const int stride= 16*2;
1581 const int xStride= 16;
1582 int a,b,c,d,e;
1583
1584 a= block[stride*0 + xStride*0];
1585 b= block[stride*0 + xStride*1];
1586 c= block[stride*1 + xStride*0];
1587 d= block[stride*1 + xStride*1];
1588
1589 e= a-b;
1590 a= a+b;
1591 b= c-d;
1592 c= c+d;
1593
1594 block[stride*0 + xStride*0]= (a+c);
1595 block[stride*0 + xStride*1]= (e+b);
1596 block[stride*1 + xStride*0]= (a-c);
1597 block[stride*1 + xStride*1]= (e-b);
1598 }
1599 #endif
1600
1601 /**
1602 * gets the chroma qp.
1603 */
1604 static inline int get_chroma_qp(H264Context *h, int t, int qscale){
1605 return h->pps.chroma_qp_table[t][qscale];
1606 }
1607
1608 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
1609 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1610 int src_x_offset, int src_y_offset,
1611 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
1612 MpegEncContext * const s = &h->s;
1613 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
1614 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
1615 const int luma_xy= (mx&3) + ((my&3)<<2);
1616 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
1617 uint8_t * src_cb, * src_cr;
1618 int extra_width= h->emu_edge_width;
1619 int extra_height= h->emu_edge_height;
1620 int emu=0;
1621 const int full_mx= mx>>2;
1622 const int full_my= my>>2;
1623 const int pic_width = 16*s->mb_width;
1624 const int pic_height = 16*s->mb_height >> MB_FIELD;
1625
1626 if(mx&7) extra_width -= 3;
1627 if(my&7) extra_height -= 3;
1628
1629 if( full_mx < 0-extra_width
1630 || full_my < 0-extra_height
1631 || full_mx + 16/*FIXME*/ > pic_width + extra_width
1632 || full_my + 16/*FIXME*/ > pic_height + extra_height){
1633 ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
1634 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
1635 emu=1;
1636 }
1637
1638 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
1639 if(!square){
1640 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
1641 }
1642
1643 if(ENABLE_GRAY && s->flags&CODEC_FLAG_GRAY) return;
1644
1645 if(MB_FIELD){
1646 // chroma offset when predicting from a field of opposite parity
1647 my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
1648 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
1649 }
1650 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
1651 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
1652
1653 if(emu){
1654 ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
1655 src_cb= s->edge_emu_buffer;
1656 }
1657 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
1658
1659 if(emu){
1660 ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
1661 src_cr= s->edge_emu_buffer;
1662 }
1663 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
1664 }
1665
1666 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
1667 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1668 int x_offset, int y_offset,
1669 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1670 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
1671 int list0, int list1){
1672 MpegEncContext * const s = &h->s;
1673 qpel_mc_func *qpix_op= qpix_put;
1674 h264_chroma_mc_func chroma_op= chroma_put;
1675
1676 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
1677 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
1678 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
1679 x_offset += 8*s->mb_x;
1680 y_offset += 8*(s->mb_y >> MB_FIELD);
1681
1682 if(list0){
1683 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
1684 mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
1685 dest_y, dest_cb, dest_cr, x_offset, y_offset,
1686 qpix_op, chroma_op);
1687
1688 qpix_op= qpix_avg;
1689 chroma_op= chroma_avg;
1690 }
1691
1692 if(list1){
1693 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
1694 mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
1695 dest_y, dest_cb, dest_cr, x_offset, y_offset,
1696 qpix_op, chroma_op);
1697 }
1698 }
1699
1700 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
1701 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1702 int x_offset, int y_offset,
1703 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1704 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
1705 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
1706 int list0, int list1){
1707 MpegEncContext * const s = &h->s;
1708
1709 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
1710 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
1711 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
1712 x_offset += 8*s->mb_x;
1713 y_offset += 8*(s->mb_y >> MB_FIELD);
1714
1715 if(list0 && list1){
1716 /* don't optimize for luma-only case, since B-frames usually
1717 * use implicit weights => chroma too. */
1718 uint8_t *tmp_cb = s->obmc_scratchpad;
1719 uint8_t *tmp_cr = s->obmc_scratchpad + 8;
1720 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize;
1721 int refn0 = h->ref_cache[0][ scan8[n] ];
1722 int refn1 = h->ref_cache[1][ scan8[n] ];
1723
1724 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
1725 dest_y, dest_cb, dest_cr,
1726 x_offset, y_offset, qpix_put, chroma_put);
1727 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
1728 tmp_y, tmp_cb, tmp_cr,
1729 x_offset, y_offset, qpix_put, chroma_put);
1730
1731 if(h->use_weight == 2){
1732 int weight0 = h->implicit_weight[refn0][refn1];
1733 int weight1 = 64 - weight0;
1734 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0);
1735 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
1736 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
1737 }else{
1738 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
1739 h->luma_weight[0][refn0], h->luma_weight[1][refn1],
1740 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
1741 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1742 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
1743 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
1744 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1745 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
1746 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
1747 }
1748 }else{
1749 int list = list1 ? 1 : 0;
1750 int refn = h->ref_cache[list][ scan8[n] ];
1751 Picture *ref= &h->ref_list[list][refn];
1752 mc_dir_part(h, ref, n, square, chroma_height, delta, list,
1753 dest_y, dest_cb, dest_cr, x_offset, y_offset,
1754 qpix_put, chroma_put);
1755
1756 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
1757 h->luma_weight[list][refn], h->luma_offset[list][refn]);
1758 if(h->use_weight_chroma){
1759 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1760 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
1761 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1762 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
1763 }
1764 }
1765 }
1766
1767 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
1768 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1769 int x_offset, int y_offset,
1770 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1771 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
1772 h264_weight_func *weight_op, h264_biweight_func *weight_avg,
1773 int list0, int list1){
1774 if((h->use_weight==2 && list0 && list1
1775 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
1776 || h->use_weight==1)
1777 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
1778 x_offset, y_offset, qpix_put, chroma_put,
1779 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
1780 else
1781 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
1782 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
1783 }
1784
1785 static inline void prefetch_motion(H264Context *h, int list){
1786 /* fetch pixels for estimated mv 4 macroblocks ahead
1787 * optimized for 64byte cache lines */
1788 MpegEncContext * const s = &h->s;
1789 const int refn = h->ref_cache[list][scan8[0]];
1790 if(refn >= 0){
1791 const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
1792 const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
1793 uint8_t **src= h->ref_list[list][refn].data;
1794 int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
1795 s->dsp.prefetch(src[0]+off, s->linesize, 4);
1796 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
1797 s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
1798 }
1799 }
1800
1801 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1802 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
1803 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
1804 h264_weight_func *weight_op, h264_biweight_func *weight_avg){
1805 MpegEncContext * const s = &h->s;
1806 const int mb_xy= h->mb_xy;
1807 const int mb_type= s->current_picture.mb_type[mb_xy];
1808
1809 assert(IS_INTER(mb_type));
1810
1811 prefetch_motion(h, 0);
1812
1813 if(IS_16X16(mb_type)){
1814 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
1815 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
1816 &weight_op[0], &weight_avg[0],
1817 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
1818 }else if(IS_16X8(mb_type)){
1819 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
1820 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
1821 &weight_op[1], &weight_avg[1],
1822 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
1823 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
1824 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
1825 &weight_op[1], &weight_avg[1],
1826 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
1827 }else if(IS_8X16(mb_type)){
1828 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
1829 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
1830 &weight_op[2], &weight_avg[2],
1831 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
1832 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
1833 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
1834 &weight_op[2], &weight_avg[2],
1835 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
1836 }else{
1837 int i;
1838
1839 assert(IS_8X8(mb_type));
1840
1841 for(i=0; i<4; i++){
1842 const int sub_mb_type= h->sub_mb_type[i];
1843 const int n= 4*i;
1844 int x_offset= (i&1)<<2;
1845 int y_offset= (i&2)<<1;
1846
1847 if(IS_SUB_8X8(sub_mb_type)){
1848 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
1849 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
1850 &weight_op[3], &weight_avg[3],
1851 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1852 }else if(IS_SUB_8X4(sub_mb_type)){
1853 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
1854 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
1855 &weight_op[4], &weight_avg[4],
1856 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1857 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
1858 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
1859 &weight_op[4], &weight_avg[4],
1860 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1861 }else if(IS_SUB_4X8(sub_mb_type)){
1862 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
1863 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
1864 &weight_op[5], &weight_avg[5],
1865 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1866 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
1867 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
1868 &weight_op[5], &weight_avg[5],
1869 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1870 }else{
1871 int j;
1872 assert(IS_SUB_4X4(sub_mb_type));
1873 for(j=0; j<4; j++){
1874 int sub_x_offset= x_offset + 2*(j&1);
1875 int sub_y_offset= y_offset + (j&2);
1876 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
1877 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
1878 &weight_op[6], &weight_avg[6],
1879 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1880 }
1881 }
1882 }
1883 }
1884
1885 prefetch_motion(h, 1);
1886 }
1887
1888 static av_cold void init_cavlc_level_tab(void){
1889 int suffix_length, mask;
1890 unsigned int i;
1891
1892 for(suffix_length=0; suffix_length<7; suffix_length++){
1893 for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
1894 int prefix= LEVEL_TAB_BITS - av_log2(2*i);
1895 int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);
1896
1897 mask= -(level_code&1);
1898 level_code= (((2+level_code)>>1) ^ mask) - mask;
1899 if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
1900 cavlc_level_tab[suffix_length][i][0]= level_code;
1901 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
1902 }else if(prefix + 1 <= LEVEL_TAB_BITS){
1903 cavlc_level_tab[suffix_length][i][0]= prefix+100;
1904 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
1905 }else{
1906 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
1907 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
1908 }
1909 }
1910 }
1911 }
1912
1913 static av_cold void decode_init_vlc(void){
1914 static int done = 0;
1915
1916 if (!done) {
1917 int i;
1918 int offset;
1919 done = 1;
1920
1921 chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
1922 chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
1923 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
1924 &chroma_dc_coeff_token_len [0], 1, 1,
1925 &chroma_dc_coeff_token_bits[0], 1, 1,
1926 INIT_VLC_USE_NEW_STATIC);
1927
1928 offset = 0;
1929 for(i=0; i<4; i++){
1930 coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
1931 coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
1932 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
1933 &coeff_token_len [i][0], 1, 1,
1934 &coeff_token_bits[i][0], 1, 1,
1935 INIT_VLC_USE_NEW_STATIC);
1936 offset += coeff_token_vlc_tables_size[i];
1937 }
1938 /*
1939 * This is a one time safety check to make sure that
1940 * the packed static coeff_token_vlc table sizes
1941 * were initialized correctly.
1942 */
1943 assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
1944
1945 for(i=0; i<3; i++){
1946 chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
1947 chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
1948 init_vlc(&chroma_dc_total_zeros_vlc[i],
1949 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
1950 &chroma_dc_total_zeros_len [i][0], 1, 1,
1951 &chroma_dc_total_zeros_bits[i][0], 1, 1,
1952 INIT_VLC_USE_NEW_STATIC);
1953 }
1954 for(i=0; i<15; i++){
1955 total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
1956 total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
1957 init_vlc(&total_zeros_vlc[i],
1958 TOTAL_ZEROS_VLC_BITS, 16,
1959 &total_zeros_len [i][0], 1, 1,
1960 &total_zeros_bits[i][0], 1, 1,
1961 INIT_VLC_USE_NEW_STATIC);
1962 }
1963
1964 for(i=0; i<6; i++){
1965 run_vlc[i].table = run_vlc_tables[i];
1966 run_vlc[i].table_allocated = run_vlc_tables_size;
1967 init_vlc(&run_vlc[i],
1968 RUN_VLC_BITS, 7,
1969 &run_len [i][0], 1, 1,
1970 &run_bits[i][0], 1, 1,
1971 INIT_VLC_USE_NEW_STATIC);
1972 }
1973 run7_vlc.table = run7_vlc_table,
1974 run7_vlc.table_allocated = run7_vlc_table_size;
1975 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
1976 &run_len [6][0], 1, 1,
1977 &run_bits[6][0], 1, 1,
1978 INIT_VLC_USE_NEW_STATIC);
1979
1980 init_cavlc_level_tab();
1981 }
1982 }
1983
1984 static void free_tables(H264Context *h){
1985 int i;
1986 H264Context *hx;
1987 av_freep(&h->intra4x4_pred_mode);
1988 av_freep(&h->chroma_pred_mode_table);
1989 av_freep(&h->cbp_table);
1990 av_freep(&h->mvd_table[0]);
1991 av_freep(&h->mvd_table[1]);
1992 av_freep(&h->direct_table);
1993 av_freep(&h->non_zero_count);
1994 av_freep(&h->slice_table_base);
1995 h->slice_table= NULL;
1996
1997 av_freep(&h->mb2b_xy);
1998 av_freep(&h->mb2b8_xy);
1999
2000 for(i = 0; i < h->s.avctx->thread_count; i++) {
2001 hx = h->thread_context[i];
2002 if(!hx) continue;
2003 av_freep(&hx->top_borders[1]);
2004 av_freep(&hx->top_borders[0]);
2005 av_freep(&hx->s.obmc_scratchpad);
2006 }
2007 }
2008
2009 static void init_dequant8_coeff_table(H264Context *h){
2010 int i,q,x;
2011 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
2012 h->dequant8_coeff[0] = h->dequant8_buffer[0];
2013 h->dequant8_coeff[1] = h->dequant8_buffer[1];
2014
2015 for(i=0; i<2; i++ ){
2016 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
2017 h->dequant8_coeff[1] = h->dequant8_buffer[0];
2018 break;
2019 }
2020
2021 for(q=0; q<52; q++){
2022 int shift = div6[q];
2023 int idx = rem6[q];
2024 for(x=0; x<64; x++)
2025 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
2026 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
2027 h->pps.scaling_matrix8[i][x]) << shift;
2028 }
2029 }
2030 }
2031
2032 static void init_dequant4_coeff_table(H264Context *h){
2033 int i,j,q,x;
2034 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
2035 for(i=0; i<6; i++ ){
2036 h->dequant4_coeff[i] = h->dequant4_buffer[i];
2037 for(j=0; j<i; j++){
2038 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
2039 h->dequant4_coeff[i] = h->dequant4_buffer[j];
2040 break;
2041 }
2042 }
2043 if(j<i)
2044 continue;
2045
2046 for(q=0; q<52; q++){
2047 int shift = div6[q] + 2;
2048 int idx = rem6[q];
2049 for(x=0; x<16; x++)
2050 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
2051 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
2052 h->pps.scaling_matrix4[i][x]) << shift;
2053 }
2054 }
2055 }
2056
2057 static void init_dequant_tables(H264Context *h){
2058 int i,x;
2059 init_dequant4_coeff_table(h);
2060 if(h->pps.transform_8x8_mode)
2061 init_dequant8_coeff_table(h);
2062 if(h->sps.transform_bypass){
2063 for(i=0; i<6; i++)
2064 for(x=0; x<16; x++)
2065 h->dequant4_coeff[i][0][x] = 1<<6;
2066 if(h->pps.transform_8x8_mode)
2067 for(i=0; i<2; i++)
2068 for(x=0; x<64; x++)
2069 h->dequant8_coeff[i][0][x] = 1<<6;
2070 }
2071 }
2072
2073
2074 /**
2075 * allocates tables.
2076 * needs width/height
2077 */
2078 static int alloc_tables(H264Context *h){
2079 MpegEncContext * const s = &h->s;
2080 const int big_mb_num= s->mb_stride * (s->mb_height+1);
2081 int x,y;
2082
2083 CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t))
2084
2085 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t))
2086 CHECKED_ALLOCZ(h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base))
2087 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
2088
2089 CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
2090 CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
2091 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
2092 CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
2093
2094 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base));
2095 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
2096
2097 CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint32_t));
2098 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
2099 for(y=0; y<s->mb_height; y++){
2100 for(x=0; x<s->mb_width; x++){
2101 const int mb_xy= x + y*s->mb_stride;
2102 const int b_xy = 4*x + 4*y*h->b_stride;
2103 const int b8_xy= 2*x + 2*y*h->b8_stride;
2104
2105 h->mb2b_xy [mb_xy]= b_xy;
2106 h->mb2b8_xy[mb_xy]= b8_xy;
2107 }
2108 }
2109
2110 s->obmc_scratchpad = NULL;
2111
2112 if(!h->dequant4_coeff[0])
2113 init_dequant_tables(h);
2114
2115 return 0;
2116 fail:
2117 free_tables(h);
2118 return -1;
2119 }
2120
2121 /**
2122 * Mimic alloc_tables(), but for every context thread.
2123 */
2124 static void clone_tables(H264Context *dst, H264Context *src){
2125 dst->intra4x4_pred_mode = src->intra4x4_pred_mode;
2126 dst->non_zero_count = src->non_zero_count;
2127 dst->slice_table = src->slice_table;
2128 dst->cbp_table = src->cbp_table;
2129 dst->mb2b_xy = src->mb2b_xy;
2130 dst->mb2b8_xy = src->mb2b8_xy;
2131 dst->chroma_pred_mode_table = src->chroma_pred_mode_table;
2132 dst->mvd_table[0] = src->mvd_table[0];
2133 dst->mvd_table[1] = src->mvd_table[1];
2134 dst->direct_table = src->direct_table;
2135
2136 dst->s.obmc_scratchpad = NULL;
2137 ff_h264_pred_init(&dst->hpc, src->s.codec_id);
2138 }
2139
2140 /**
2141 * Init context
2142 * Allocate buffers which are not shared amongst multiple threads.
2143 */
2144 static int context_init(H264Context *h){
2145 CHECKED_ALLOCZ(h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t))
2146 CHECKED_ALLOCZ(h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t))
2147
2148 return 0;
2149 fail:
2150 return -1; // free_tables will clean up for us
2151 }
2152
2153 static av_cold void common_init(H264Context *h){
2154 MpegEncContext * const s = &h->s;
2155
2156 s->width = s->avctx->width;
2157 s->height = s->avctx->height;
2158 s->codec_id= s->avctx->codec->id;
2159
2160 ff_h264_pred_init(&h->hpc, s->codec_id);
2161
2162 h->dequant_coeff_pps= -1;
2163 s->unrestricted_mv=1;
2164 s->decode=1; //FIXME
2165
2166 dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
2167
2168 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
2169 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
2170 }
2171
2172 static av_cold int decode_init(AVCodecContext *avctx){
2173 H264Context *h= avctx->priv_data;
2174 MpegEncContext * const s = &h->s;
2175
2176 MPV_decode_defaults(s);
2177
2178 s->avctx = avctx;
2179 common_init(h);
2180
2181 s->out_format = FMT_H264;
2182 s->workaround_bugs= avctx->workaround_bugs;
2183
2184 // set defaults
2185 // s->decode_mb= ff_h263_decode_mb;
2186 s->quarter_sample = 1;
2187 s->low_delay= 1;
2188
2189 if(avctx->codec_id == CODEC_ID_SVQ3)
2190 avctx->pix_fmt= PIX_FMT_YUVJ420P;
2191 else
2192 avctx->pix_fmt= PIX_FMT_YUV420P;
2193
2194 decode_init_vlc();
2195
2196 if(avctx->extradata_size > 0 && avctx->extradata &&
2197 *(char *)avctx->extradata == 1){
2198 h->is_avc = 1;
2199 h->got_avcC = 0;
2200 } else {
2201 h->is_avc = 0;
2202 }
2203
2204 h->thread_context[0] = h;
2205 h->outputed_poc = INT_MIN;
2206 h->prev_poc_msb= 1<<16;
2207 return 0;
2208 }
2209
2210 static int frame_start(H264Context *h){
2211 MpegEncContext * const s = &h->s;
2212 int i;
2213
2214 if(MPV_frame_start(s, s->avctx) < 0)
2215 return -1;
2216 ff_er_frame_start(s);
2217 /*
2218 * MPV_frame_start uses pict_type to derive key_frame.
2219 * This is incorrect for H.264; IDR markings must be used.
2220 * Zero here; IDR markings per slice in frame or fields are ORed in later.
2221 * See decode_nal_units().
2222 */
2223 s->current_picture_ptr->key_frame= 0;
2224
2225 assert(s->linesize && s->uvlinesize);
2226
2227 for(i=0; i<16; i++){
2228 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
2229 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
2230 }
2231 for(i=0; i<4; i++){
2232 h->block_offset[16+i]=
2233 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2234 h->block_offset[24+16+i]=
2235 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2236 }
2237
2238 /* can't be in alloc_tables because linesize isn't known there.
2239 * FIXME: redo bipred weight to not require extra buffer? */
2240 for(i = 0; i < s->avctx->thread_count; i++)
2241 if(!h->thread_context[i]->s.obmc_scratchpad)
2242 h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
2243
2244 /* some macroblocks will be accessed before they're available */
2245 if(FRAME_MBAFF || s->avctx->thread_count > 1)
2246 memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
2247
2248 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
2249
2250 // We mark the current picture as non-reference after allocating it, so
2251 // that if we break out due to an error it can be released automatically
2252 // in the next MPV_frame_start().
2253 // SVQ3 as well as most other codecs have only last/next/current and thus
2254 // get released even with set reference, besides SVQ3 and others do not
2255 // mark frames as reference later "naturally".
2256 if(s->codec_id != CODEC_ID_SVQ3)
2257 s->current_picture_ptr->reference= 0;
2258
2259 s->current_picture_ptr->field_poc[0]=
2260 s->current_picture_ptr->field_poc[1]= INT_MAX;
2261 assert(s->current_picture_ptr->long_ref==0);
2262
2263 return 0;
2264 }
2265
2266 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){
2267 MpegEncContext * const s = &h->s;
2268 int i;
2269 int step = 1;
2270 int offset = 1;
2271 int uvoffset= 1;
2272 int top_idx = 1;
2273 int skiplast= 0;
2274
2275 src_y -= linesize;
2276 src_cb -= uvlinesize;
2277 src_cr -= uvlinesize;
2278
2279 if(!simple && FRAME_MBAFF){
2280 if(s->mb_y&1){
2281 offset = MB_MBAFF ? 1 : 17;
2282 uvoffset= MB_MBAFF ? 1 : 9;
2283 if(!MB_MBAFF){
2284 *(uint64_t*)(h->top_borders[0][s->mb_x]+ 0)= *(uint64_t*)(src_y + 15*linesize);
2285 *(uint64_t*)(h->top_borders[0][s->mb_x]+ 8)= *(uint64_t*)(src_y +8+15*linesize);
2286 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2287 *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+7*uvlinesize);
2288 *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+7*uvlinesize);
2289 }
2290 }
2291 }else{
2292 if(!MB_MBAFF){
2293 h->left_border[0]= h->top_borders[0][s->mb_x][15];
2294 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2295 h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7 ];
2296 h->left_border[34+18]= h->top_borders[0][s->mb_x][16+8+7];
2297 }
2298 skiplast= 1;
2299 }
2300 offset =
2301 uvoffset=
2302 top_idx = MB_MBAFF ? 0 : 1;
2303 }
2304 step= MB_MBAFF ? 2 : 1;
2305 }
2306
2307 // There are two lines saved, the line above the the top macroblock of a pair,
2308 // and the line above the bottom macroblock
2309 h->left_border[offset]= h->top_borders[top_idx][s->mb_x][15];
2310 for(i=1; i<17 - skiplast; i++){
2311 h->left_border[offset+i*step]= src_y[15+i* linesize];
2312 }
2313
2314 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize);
2315 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
2316
2317 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2318 h->left_border[uvoffset+34 ]= h->top_borders[top_idx][s->mb_x][16+7];
2319 h->left_border[uvoffset+34+18]= h->top_borders[top_idx][s->mb_x][24+7];
2320 for(i=1; i<9 - skiplast; i++){
2321 h->left_border[uvoffset+34 +i*step]= src_cb[7+i*uvlinesize];
2322 h->left_border[uvoffset+34+18+i*step]= src_cr[7+i*uvlinesize];
2323 }
2324 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
2325 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
2326 }
2327 }
2328
2329 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, int simple){
2330 MpegEncContext * const s = &h->s;
2331 int temp8, i;
2332 uint64_t temp64;
2333 int deblock_left;
2334 int deblock_top;
2335 int mb_xy;
2336 int step = 1;
2337 int offset = 1;
2338 int uvoffset= 1;
2339 int top_idx = 1;
2340
2341 if(!simple && FRAME_MBAFF){
2342 if(s->mb_y&1){
2343 offset = MB_MBAFF ? 1 : 17;
2344 uvoffset= MB_MBAFF ? 1 : 9;
2345 }else{
2346 offset =
2347 uvoffset=
2348 top_idx = MB_MBAFF ? 0 : 1;
2349 }
2350 step= MB_MBAFF ? 2 : 1;
2351 }
2352
2353 if(h->deblocking_filter == 2) {
2354 mb_xy = h->mb_xy;
2355 deblock_left = h->slice_table[mb_xy] == h->slice_table[mb_xy - 1];
2356 deblock_top = h->slice_table[mb_xy] == h->slice_table[h->top_mb_xy];
2357 } else {
2358 deblock_left = (s->mb_x > 0);
2359 deblock_top = (s->mb_y > !!MB_FIELD);
2360 }
2361
2362 src_y -= linesize + 1;
2363 src_cb -= uvlinesize + 1;
2364 src_cr -= uvlinesize + 1;
2365
2366 #define XCHG(a,b,t,xchg)\
2367 t= a;\
2368 if(xchg)\
2369 a= b;\
2370 b= t;
2371
2372 if(deblock_left){
2373 for(i = !deblock_top; i<16; i++){
2374 XCHG(h->left_border[offset+i*step], src_y [i* linesize], temp8, xchg);
2375 }
2376 XCHG(h->left_border[offset+i*step], src_y [i* linesize], temp8, 1);
2377 }
2378
2379 if(deblock_top){
2380 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
2381 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
2382 if(s->mb_x+1 < s->mb_width){
2383 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
2384 }
2385 }
2386
2387 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2388 if(deblock_left){
2389 for(i = !deblock_top; i<8; i++){
2390 XCHG(h->left_border[uvoffset+34 +i*step], src_cb[i*uvlinesize], temp8, xchg);
2391 XCHG(h->left_border[uvoffset+34+18+i*step], src_cr[i*uvlinesize], temp8, xchg);
2392 }
2393 XCHG(h->left_border[uvoffset+34 +i*step], src_cb[i*uvlinesize], temp8, 1);
2394 XCHG(h->left_border[uvoffset+34+18+i*step], src_cr[i*uvlinesize], temp8, 1);
2395 }
2396 if(deblock_top){
2397 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
2398 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
2399 }
2400 }
2401 }
2402
2403 static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){
2404 MpegEncContext * const s = &h->s;
2405 const int mb_x= s->mb_x;
2406 const int mb_y= s->mb_y;
2407 const int mb_xy= h->mb_xy;
2408 const int mb_type= s->current_picture.mb_type[mb_xy];
2409 uint8_t *dest_y, *dest_cb, *dest_cr;
2410 int linesize, uvlinesize /*dct_offset*/;
2411 int i;
2412 int *block_offset = &h->block_offset[0];
2413 const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
2414 const int is_h264 = simple || s->codec_id == CODEC_ID_H264;
2415 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
2416 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
2417
2418 dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
2419 dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
2420 dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
2421
2422 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
2423 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);
2424
2425 if (!simple && MB_FIELD) {
2426 linesize = h->mb_linesize = s->linesize * 2;
2427 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
2428 block_offset = &h->block_offset[24];
2429 if(mb_y&1){ //FIXME move out of this function?
2430 dest_y -= s->linesize*15;
2431 dest_cb-= s->uvlinesize*7;
2432 dest_cr-= s->uvlinesize*7;
2433 }
2434 if(FRAME_MBAFF) {
2435 int list;
2436 for(list=0; list<h->list_count; list++){
2437 if(!USES_LIST(mb_type, list))
2438 continue;
2439 if(IS_16X16(mb_type)){
2440 int8_t *ref = &h->ref_cache[list][scan8[0]];
2441 fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
2442 }else{
2443 for(i=0; i<16; i+=4){
2444 int ref = h->ref_cache[list][scan8[i]];
2445 if(ref >= 0)
2446 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
2447 }
2448 }
2449 }
2450 }
2451 } else {
2452 linesize = h->mb_linesize = s->linesize;
2453 uvlinesize = h->mb_uvlinesize = s->uvlinesize;
2454 // dct_offset = s->linesize * 16;
2455 }
2456
2457 if (!simple && IS_INTRA_PCM(mb_type)) {
2458 for (i=0; i<16; i++) {
2459 memcpy(dest_y + i* linesize, h->mb + i*8, 16);
2460 }
2461 for (i=0; i<8; i++) {
2462 memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4, 8);
2463 memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4, 8);
2464 }
2465 } else {
2466 if(IS_INTRA(mb_type)){
2467 if(h->deblocking_filter)
2468 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
2469
2470 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2471 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
2472 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
2473 }
2474
2475 if(IS_INTRA4x4(mb_type)){
2476 if(simple || !s->encoding){
2477 if(IS_8x8DCT(mb_type)){
2478 if(transform_bypass){
2479 idct_dc_add =
2480 idct_add = s->dsp.add_pixels8;
2481 }else{
2482 idct_dc_add = s->dsp.h264_idct8_dc_add;
2483 idct_add = s->dsp.h264_idct8_add;
2484 }
2485 for(i=0; i<16; i+=4){
2486 uint8_t * const ptr= dest_y + block_offset[i];
2487 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2488 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
2489 h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);
2490 }else{
2491 const int nnz = h->non_zero_count_cache[ scan8[i] ];
2492 h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
2493 (h->topright_samples_available<<i)&0x4000, linesize);
2494 if(nnz){
2495 if(nnz == 1 && h->mb[i*16])
2496 idct_dc_add(ptr, h->mb + i*16, linesize);
2497 else
2498 idct_add (ptr, h->mb + i*16, linesize);
2499 }
2500 }
2501 }
2502 }else{
2503 if(transform_bypass){
2504 idct_dc_add =
2505 idct_add = s->dsp.add_pixels4;
2506 }else{
2507 idct_dc_add = s->dsp.h264_idct_dc_add;
2508 idct_add = s->dsp.h264_idct_add;
2509 }
2510 for(i=0; i<16; i++){
2511 uint8_t * const ptr= dest_y + block_offset[i];
2512 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2513
2514 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
2515 h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
2516 }else{
2517 uint8_t *topright;
2518 int nnz, tr;
2519 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
2520 const int topright_avail= (h->topright_samples_available<<i)&0x8000;
2521 assert(mb_y || linesize <= block_offset[i]);
2522 if(!topright_avail){
2523 tr= ptr[3 - linesize]*0x01010101;
2524 topright= (uint8_t*) &tr;
2525 }else
2526 topright= ptr + 4 - linesize;
2527 }else
2528 topright= NULL;
2529
2530 h->hpc.pred4x4[ dir ](ptr, topright, linesize);
2531 nnz = h->non_zero_count_cache[ scan8[i] ];
2532 if(nnz){
2533 if(is_h264){
2534 if(nnz == 1 && h->mb[i*16])
2535 idct_dc_add(ptr, h->mb + i*16, linesize);
2536 else
2537 idct_add (ptr, h->mb + i*16, linesize);
2538 }else
2539 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
2540 }
2541 }
2542 }
2543 }
2544 }
2545 }else{
2546 h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
2547 if(is_h264){
2548 if(!transform_bypass)
2549 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]);
2550 }else
2551 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
2552 }
2553 if(h->deblocking_filter)
2554 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);
2555 }else if(is_h264){
2556 hl_motion(h, dest_y, dest_cb, dest_cr,
2557 s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
2558 s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
2559 s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
2560 }
2561
2562
2563 if(!IS_INTRA4x4(mb_type)){
2564 if(is_h264){
2565 if(IS_INTRA16x16(mb_type)){
2566 if(transform_bypass){
2567 if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
2568 h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
2569 }else{
2570 for(i=0; i<16; i++){
2571 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2572 s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize);
2573 }
2574 }
2575 }else{
2576 s->dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2577 }
2578 }else if(h->cbp&15){
2579 if(transform_bypass){
2580 const int di = IS_8x8DCT(mb_type) ? 4 : 1;
2581 idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
2582 for(i=0; i<16; i+=di){
2583 if(h->non_zero_count_cache[ scan8[i] ]){
2584 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
2585 }
2586 }
2587 }else{
2588 if(IS_8x8DCT(mb_type)){
2589 s->dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2590 }else{
2591 s->dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2592 }
2593 }
2594 }
2595 }else{
2596 for(i=0; i<16; i++){
2597 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
2598 uint8_t * const ptr= dest_y + block_offset[i];
2599 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
2600 }
2601 }
2602 }
2603 }
2604
2605 if((simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
2606 uint8_t *dest[2] = {dest_cb, dest_cr};
2607 if(transform_bypass){
2608 if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
2609 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize);
2610 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize);
2611 }else{
2612 idct_add = s->dsp.add_pixels4;
2613 for(i=16; i<16+8; i++){
2614 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2615 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2616 }
2617 }
2618 }else{
2619 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp[0], h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
2620 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp[1], h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
2621 if(is_h264){
2622 idct_add = s->dsp.h264_idct_add;
2623 idct_dc_add = s->dsp.h264_idct_dc_add;
2624 for(i=16; i<16+8; i++){
2625 if(h->non_zero_count_cache[ scan8[i] ])
2626 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2627 else if(h->mb[i*16])
2628 idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2629 }
2630 }else{
2631 for(i=16; i<16+8; i++){
2632 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2633 uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
2634 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
2635 }
2636 }
2637 }
2638 }
2639 }
2640 }
2641 if(h->cbp || IS_INTRA(mb_type))
2642 s->dsp.clear_blocks(h->mb);
2643
2644 if(h->deblocking_filter) {
2645 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, simple);
2646 fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
2647 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
2648 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
2649 if (!simple && FRAME_MBAFF) {
2650 filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2651 } else {
2652 filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2653 }
2654 }
2655 }
2656
2657 /**
2658 * Process a macroblock; this case avoids checks for expensive uncommon cases.
2659 */
2660 static void hl_decode_mb_simple(H264Context *h){
2661 hl_decode_mb_internal(h, 1);
2662 }
2663
2664 /**
2665 * Process a macroblock; this handles edge cases, such as interlacing.
2666 */
2667 static void av_noinline hl_decode_mb_complex(H264Context *h){
2668 hl_decode_mb_internal(h, 0);
2669 }
2670
2671 static void hl_decode_mb(H264Context *h){
2672 MpegEncContext * const s = &h->s;
2673 const int mb_xy= h->mb_xy;
2674 const int mb_type= s->current_picture.mb_type[mb_xy];
2675 int is_complex = ENABLE_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
2676
2677 if(ENABLE_H264_ENCODER && !s->decode)
2678 return;
2679
2680 if (is_complex)
2681 hl_decode_mb_complex(h);
2682 else hl_decode_mb_simple(h);
2683 }
2684
2685 static void pic_as_field(Picture *pic, const int parity){
2686 int i;
2687 for (i = 0; i < 4; ++i) {
2688 if (parity == PICT_BOTTOM_FIELD)
2689 pic->data[i] += pic->linesize[i];
2690 pic->reference = parity;
2691 pic->linesize[i] *= 2;
2692 }
2693 pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD];
2694 }
2695
2696 static int split_field_copy(Picture *dest, Picture *src,
2697 int parity, int id_add){
2698 int match = !!(src->reference & parity);
2699
2700 if (match) {
2701 *dest = *src;
2702 if(parity != PICT_FRAME){
2703 pic_as_field(dest, parity);
2704 dest->pic_id *= 2;
2705 dest->pic_id += id_add;
2706 }
2707 }
2708
2709 return match;
2710 }
2711
2712 static int build_def_list(Picture *def, Picture **in, int len, int is_long, int sel){
2713 int i[2]={0};
2714 int index=0;
2715
2716 while(i[0]<len || i[1]<len){
2717 while(i[0]<len && !(in[ i[0] ] && (in[ i[0] ]->reference & sel)))
2718 i[0]++;
2719 while(i[1]<len && !(in[ i[1] ] && (in[ i[1] ]->reference & (sel^3))))
2720 i[1]++;
2721 if(i[0] < len){
2722 in[ i[0] ]->pic_id= is_long ? i[0] : in[ i[0] ]->frame_num;
2723 split_field_copy(&def[index++], in[ i[0]++ ], sel , 1);
2724 }
2725 if(i[1] < len){
2726 in[ i[1] ]->pic_id= is_long ? i[1] : in[ i[1] ]->frame_num;
2727 split_field_copy(&def[index++], in[ i[1]++ ], sel^3, 0);
2728 }
2729 }
2730
2731 return index;
2732 }
2733
2734 static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir){
2735 int i, best_poc;
2736 int out_i= 0;
2737
2738 for(;;){
2739 best_poc= dir ? INT_MIN : INT_MAX;
2740
2741 for(i=0; i<len; i++){
2742 const int poc= src[i]->poc;
2743 if(((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)){
2744 best_poc= poc;
2745 sorted[out_i]= src[i];
2746 }
2747 }
2748 if(best_poc == (dir ? INT_MIN : INT_MAX))
2749 break;
2750 limit= sorted[out_i++]->poc - dir;
2751 }
2752 return out_i;
2753 }
2754
2755 /**
2756 * fills the default_ref_list.
2757 */
2758 static int fill_default_ref_list(H264Context *h){
2759 MpegEncContext * const s = &h->s;
2760 int i, len;
2761
2762 if(h->slice_type_nos==FF_B_TYPE){
2763 Picture *sorted[32];
2764 int cur_poc, list;
2765 int lens[2];
2766
2767 if(FIELD_PICTURE)
2768 cur_poc= s->current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
2769 else
2770 cur_poc= s->current_picture_ptr->poc;
2771
2772 for(list= 0; list<2; list++){
2773 len= add_sorted(sorted , h->short_ref, h->short_ref_count, cur_poc, 1^list);
2774 len+=add_sorted(sorted+len, h->short_ref, h->short_ref_count, cur_poc, 0^list);
2775 assert(len<=32);
2776 len= build_def_list(h->default_ref_list[list] , sorted , len, 0, s->picture_structure);
2777 len+=build_def_list(h->default_ref_list[list]+len, h->long_ref, 16 , 1, s->picture_structure);
2778 assert(len<=32);
2779
2780 if(len < h->ref_count[list])
2781 memset(&h->default_ref_list[list][len], 0, sizeof(Picture)*(h->ref_count[list] - len));
2782 lens[list]= len;
2783 }
2784
2785 if(lens[0] == lens[1] && lens[1] > 1){
2786 for(i=0; h->default_ref_list[0][i].data[0] == h->default_ref_list[1][i].data[0] && i<lens[0]; i++);
2787 if(i == lens[0])
2788 FFSWAP(Picture, h->default_ref_list[1][0], h->default_ref_list[1][1]);
2789 }
2790 }else{
2791 len = build_def_list(h->default_ref_list[0] , h->short_ref, h->short_ref_count, 0, s->picture_structure);
2792 len+= build_def_list(h->default_ref_list[0]+len, h-> long_ref, 16 , 1, s->picture_structure);
2793 assert(len <= 32);
2794 if(len < h->ref_count[0])
2795 memset(&h->default_ref_list[0][len], 0, sizeof(Picture)*(h->ref_count[0] - len));
2796 }
2797 #ifdef TRACE
2798 for (i=0; i<h->ref_count[0]; i++) {
2799 tprintf(h->s.avctx, "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]);
2800 }
2801 if(h->slice_type_nos==FF_B_TYPE){
2802 for (i=0; i<h->ref_count[1]; i++) {
2803 tprintf(h->s.avctx, "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[1][i].data[0]);
2804 }
2805 }
2806 #endif
2807 return 0;
2808 }
2809
2810 static void print_short_term(H264Context *h);
2811 static void print_long_term(H264Context *h);
2812
2813 /**
2814 * Extract structure information about the picture described by pic_num in
2815 * the current decoding context (frame or field). Note that pic_num is
2816 * picture number without wrapping (so, 0<=pic_num<max_pic_num).
2817 * @param pic_num picture number for which to extract structure information
2818 * @param structure one of PICT_XXX describing structure of picture
2819 * with pic_num
2820 * @return frame number (short term) or long term index of picture
2821 * described by pic_num
2822 */
2823 static int pic_num_extract(H264Context *h, int pic_num, int *structure){
2824 MpegEncContext * const s = &h->s;
2825
2826 *structure = s->picture_structure;
2827 if(FIELD_PICTURE){
2828 if (!(pic_num & 1))
2829 /* opposite field */
2830 *structure ^= PICT_FRAME;
2831 pic_num >>= 1;
2832 }
2833
2834 return pic_num;
2835 }
2836
2837 static int decode_ref_pic_list_reordering(H264Context *h){
2838 MpegEncContext * const s = &h->s;
2839 int list, index, pic_structure;
2840
2841 print_short_term(h);
2842 print_long_term(h);
2843
2844 for(list=0; list<h->list_count; list++){
2845 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
2846
2847 if(get_bits1(&s->gb)){
2848 int pred= h->curr_pic_num;
2849
2850 for(index=0; ; index++){
2851 unsigned int reordering_of_pic_nums_idc= get_ue_golomb_31(&s->gb);
2852 unsigned int pic_id;
2853 int i;
2854 Picture *ref = NULL;
2855
2856 if(reordering_of_pic_nums_idc==3)
2857 break;
2858
2859 if(index >= h->ref_count[list]){
2860 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
2861 return -1;
2862 }
2863
2864 if(reordering_of_pic_nums_idc<3){
2865 if(reordering_of_pic_nums_idc<2){
2866 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
2867 int frame_num;
2868
2869 if(abs_diff_pic_num > h->max_pic_num){
2870 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
2871 return -1;
2872 }
2873
2874 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
2875 else pred+= abs_diff_pic_num;
2876 pred &= h->max_pic_num - 1