ab206a2b6f4e01a30f65640fe45ec4a47e8bcc6a
[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 == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
877 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
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 si=di=0;
1427 while(si<length){
1428 //remove escapes (very rare 1:2^22)
1429 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1430 if(src[si+2]==3){ //escape
1431 dst[di++]= 0;
1432 dst[di++]= 0;
1433 si+=3;
1434 continue;
1435 }else //next start code
1436 break;
1437 }
1438
1439 dst[di++]= src[si++];
1440 }
1441
1442 memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1443
1444 *dst_length= di;
1445 *consumed= si + 1;//+1 for the header
1446 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
1447 return dst;
1448 }
1449
1450 /**
1451 * identifies the exact end of the bitstream
1452 * @return the length of the trailing, or 0 if damaged
1453 */
1454 static int decode_rbsp_trailing(H264Context *h, const uint8_t *src){
1455 int v= *src;
1456 int r;
1457
1458 tprintf(h->s.avctx, "rbsp trailing %X\n", v);
1459
1460 for(r=1; r<9; r++){
1461 if(v&1) return r;
1462 v>>=1;
1463 }
1464 return 0;
1465 }
1466
1467 /**
1468 * IDCT transforms the 16 dc values and dequantizes them.
1469 * @param qp quantization parameter
1470 */
1471 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1472 #define stride 16
1473 int i;
1474 int temp[16]; //FIXME check if this is a good idea
1475 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
1476 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1477
1478 //memset(block, 64, 2*256);
1479 //return;
1480 for(i=0; i<4; i++){
1481 const int offset= y_offset[i];
1482 const int z0= block[offset+stride*0] + block[offset+stride*4];
1483 const int z1= block[offset+stride*0] - block[offset+stride*4];
1484 const int z2= block[offset+stride*1] - block[offset+stride*5];
1485 const int z3= block[offset+stride*1] + block[offset+stride*5];
1486
1487 temp[4*i+0]= z0+z3;
1488 temp[4*i+1]= z1+z2;
1489 temp[4*i+2]= z1-z2;
1490 temp[4*i+3]= z0-z3;
1491 }
1492
1493 for(i=0; i<4; i++){
1494 const int offset= x_offset[i];
1495 const int z0= temp[4*0+i] + temp[4*2+i];
1496 const int z1= temp[4*0+i] - temp[4*2+i];
1497 const int z2= temp[4*1+i] - temp[4*3+i];
1498 const int z3= temp[4*1+i] + temp[4*3+i];
1499
1500 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual
1501 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
1502 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
1503 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
1504 }
1505 }
1506
1507 #if 0
1508 /**
1509 * DCT transforms the 16 dc values.
1510 * @param qp quantization parameter ??? FIXME
1511 */
1512 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
1513 // const int qmul= dequant_coeff[qp][0];
1514 int i;
1515 int temp[16]; //FIXME check if this is a good idea
1516 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
1517 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1518
1519 for(i=0; i<4; i++){
1520 const int offset= y_offset[i];
1521 const int z0= block[offset+stride*0] + block[offset+stride*4];
1522 const int z1= block[offset+stride*0] - block[offset+stride*4];
1523 const int z2= block[offset+stride*1] - block[offset+stride*5];
1524 const int z3= block[offset+stride*1] + block[offset+stride*5];
1525
1526 temp[4*i+0]= z0+z3;
1527 temp[4*i+1]= z1+z2;
1528 temp[4*i+2]= z1-z2;
1529 temp[4*i+3]= z0-z3;
1530 }
1531
1532 for(i=0; i<4; i++){
1533 const int offset= x_offset[i];
1534 const int z0= temp[4*0+i] + temp[4*2+i];
1535 const int z1= temp[4*0+i] - temp[4*2+i];
1536 const int z2= temp[4*1+i] - temp[4*3+i];
1537 const int z3= temp[4*1+i] + temp[4*3+i];
1538
1539 block[stride*0 +offset]= (z0 + z3)>>1;
1540 block[stride*2 +offset]= (z1 + z2)>>1;
1541 block[stride*8 +offset]= (z1 - z2)>>1;
1542 block[stride*10+offset]= (z0 - z3)>>1;
1543 }
1544 }
1545 #endif
1546
1547 #undef xStride
1548 #undef stride
1549
1550 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1551 const int stride= 16*2;
1552 const int xStride= 16;
1553 int a,b,c,d,e;
1554
1555 a= block[stride*0 + xStride*0];
1556 b= block[stride*0 + xStride*1];
1557 c= block[stride*1 + xStride*0];
1558 d= block[stride*1 + xStride*1];
1559
1560 e= a-b;
1561 a= a+b;
1562 b= c-d;
1563 c= c+d;
1564
1565 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
1566 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
1567 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
1568 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
1569 }
1570
1571 #if 0
1572 static void chroma_dc_dct_c(DCTELEM *block){
1573 const int stride= 16*2;
1574 const int xStride= 16;
1575 int a,b,c,d,e;
1576
1577 a= block[stride*0 + xStride*0];
1578 b= block[stride*0 + xStride*1];
1579 c= block[stride*1 + xStride*0];
1580 d= block[stride*1 + xStride*1];
1581
1582 e= a-b;
1583 a= a+b;
1584 b= c-d;
1585 c= c+d;
1586
1587 block[stride*0 + xStride*0]= (a+c);
1588 block[stride*0 + xStride*1]= (e+b);
1589 block[stride*1 + xStride*0]= (a-c);
1590 block[stride*1 + xStride*1]= (e-b);
1591 }
1592 #endif
1593
1594 /**
1595 * gets the chroma qp.
1596 */
1597 static inline int get_chroma_qp(H264Context *h, int t, int qscale){
1598 return h->pps.chroma_qp_table[t][qscale];
1599 }
1600
1601 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
1602 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1603 int src_x_offset, int src_y_offset,
1604 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
1605 MpegEncContext * const s = &h->s;
1606 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
1607 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
1608 const int luma_xy= (mx&3) + ((my&3)<<2);
1609 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
1610 uint8_t * src_cb, * src_cr;
1611 int extra_width= h->emu_edge_width;
1612 int extra_height= h->emu_edge_height;
1613 int emu=0;
1614 const int full_mx= mx>>2;
1615 const int full_my= my>>2;
1616 const int pic_width = 16*s->mb_width;
1617 const int pic_height = 16*s->mb_height >> MB_FIELD;
1618
1619 if(mx&7) extra_width -= 3;
1620 if(my&7) extra_height -= 3;
1621
1622 if( full_mx < 0-extra_width
1623 || full_my < 0-extra_height
1624 || full_mx + 16/*FIXME*/ > pic_width + extra_width
1625 || full_my + 16/*FIXME*/ > pic_height + extra_height){
1626 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);
1627 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
1628 emu=1;
1629 }
1630
1631 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
1632 if(!square){
1633 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
1634 }
1635
1636 if(ENABLE_GRAY && s->flags&CODEC_FLAG_GRAY) return;
1637
1638 if(MB_FIELD){
1639 // chroma offset when predicting from a field of opposite parity
1640 my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
1641 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
1642 }
1643 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
1644 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
1645
1646 if(emu){
1647 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);
1648 src_cb= s->edge_emu_buffer;
1649 }
1650 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
1651
1652 if(emu){
1653 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);
1654 src_cr= s->edge_emu_buffer;
1655 }
1656 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
1657 }
1658
1659 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
1660 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1661 int x_offset, int y_offset,
1662 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1663 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
1664 int list0, int list1){
1665 MpegEncContext * const s = &h->s;
1666 qpel_mc_func *qpix_op= qpix_put;
1667 h264_chroma_mc_func chroma_op= chroma_put;
1668
1669 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
1670 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
1671 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
1672 x_offset += 8*s->mb_x;
1673 y_offset += 8*(s->mb_y >> MB_FIELD);
1674
1675 if(list0){
1676 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
1677 mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
1678 dest_y, dest_cb, dest_cr, x_offset, y_offset,
1679 qpix_op, chroma_op);
1680
1681 qpix_op= qpix_avg;
1682 chroma_op= chroma_avg;
1683 }
1684
1685 if(list1){
1686 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
1687 mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
1688 dest_y, dest_cb, dest_cr, x_offset, y_offset,
1689 qpix_op, chroma_op);
1690 }
1691 }
1692
1693 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
1694 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1695 int x_offset, int y_offset,
1696 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1697 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
1698 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
1699 int list0, int list1){
1700 MpegEncContext * const s = &h->s;
1701
1702 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
1703 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
1704 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
1705 x_offset += 8*s->mb_x;
1706 y_offset += 8*(s->mb_y >> MB_FIELD);
1707
1708 if(list0 && list1){
1709 /* don't optimize for luma-only case, since B-frames usually
1710 * use implicit weights => chroma too. */
1711 uint8_t *tmp_cb = s->obmc_scratchpad;
1712 uint8_t *tmp_cr = s->obmc_scratchpad + 8;
1713 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize;
1714 int refn0 = h->ref_cache[0][ scan8[n] ];
1715 int refn1 = h->ref_cache[1][ scan8[n] ];
1716
1717 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
1718 dest_y, dest_cb, dest_cr,
1719 x_offset, y_offset, qpix_put, chroma_put);
1720 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
1721 tmp_y, tmp_cb, tmp_cr,
1722 x_offset, y_offset, qpix_put, chroma_put);
1723
1724 if(h->use_weight == 2){
1725 int weight0 = h->implicit_weight[refn0][refn1];
1726 int weight1 = 64 - weight0;
1727 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0);
1728 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
1729 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
1730 }else{
1731 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
1732 h->luma_weight[0][refn0], h->luma_weight[1][refn1],
1733 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
1734 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1735 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
1736 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
1737 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1738 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
1739 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
1740 }
1741 }else{
1742 int list = list1 ? 1 : 0;
1743 int refn = h->ref_cache[list][ scan8[n] ];
1744 Picture *ref= &h->ref_list[list][refn];
1745 mc_dir_part(h, ref, n, square, chroma_height, delta, list,
1746 dest_y, dest_cb, dest_cr, x_offset, y_offset,
1747 qpix_put, chroma_put);
1748
1749 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
1750 h->luma_weight[list][refn], h->luma_offset[list][refn]);
1751 if(h->use_weight_chroma){
1752 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1753 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
1754 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1755 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
1756 }
1757 }
1758 }
1759
1760 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
1761 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1762 int x_offset, int y_offset,
1763 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
1764 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
1765 h264_weight_func *weight_op, h264_biweight_func *weight_avg,
1766 int list0, int list1){
1767 if((h->use_weight==2 && list0 && list1
1768 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
1769 || h->use_weight==1)
1770 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
1771 x_offset, y_offset, qpix_put, chroma_put,
1772 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
1773 else
1774 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
1775 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
1776 }
1777
1778 static inline void prefetch_motion(H264Context *h, int list){
1779 /* fetch pixels for estimated mv 4 macroblocks ahead
1780 * optimized for 64byte cache lines */
1781 MpegEncContext * const s = &h->s;
1782 const int refn = h->ref_cache[list][scan8[0]];
1783 if(refn >= 0){
1784 const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
1785 const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
1786 uint8_t **src= h->ref_list[list][refn].data;
1787 int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
1788 s->dsp.prefetch(src[0]+off, s->linesize, 4);
1789 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
1790 s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
1791 }
1792 }
1793
1794 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1795 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
1796 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
1797 h264_weight_func *weight_op, h264_biweight_func *weight_avg){
1798 MpegEncContext * const s = &h->s;
1799 const int mb_xy= h->mb_xy;
1800 const int mb_type= s->current_picture.mb_type[mb_xy];
1801
1802 assert(IS_INTER(mb_type));
1803
1804 prefetch_motion(h, 0);
1805
1806 if(IS_16X16(mb_type)){
1807 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
1808 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
1809 &weight_op[0], &weight_avg[0],
1810 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
1811 }else if(IS_16X8(mb_type)){
1812 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
1813 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
1814 &weight_op[1], &weight_avg[1],
1815 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
1816 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
1817 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
1818 &weight_op[1], &weight_avg[1],
1819 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
1820 }else if(IS_8X16(mb_type)){
1821 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
1822 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
1823 &weight_op[2], &weight_avg[2],
1824 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
1825 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
1826 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
1827 &weight_op[2], &weight_avg[2],
1828 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
1829 }else{
1830 int i;
1831
1832 assert(IS_8X8(mb_type));
1833
1834 for(i=0; i<4; i++){
1835 const int sub_mb_type= h->sub_mb_type[i];
1836 const int n= 4*i;
1837 int x_offset= (i&1)<<2;
1838 int y_offset= (i&2)<<1;
1839
1840 if(IS_SUB_8X8(sub_mb_type)){
1841 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
1842 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
1843 &weight_op[3], &weight_avg[3],
1844 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1845 }else if(IS_SUB_8X4(sub_mb_type)){
1846 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
1847 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
1848 &weight_op[4], &weight_avg[4],
1849 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1850 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
1851 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
1852 &weight_op[4], &weight_avg[4],
1853 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1854 }else if(IS_SUB_4X8(sub_mb_type)){
1855 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
1856 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
1857 &weight_op[5], &weight_avg[5],
1858 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1859 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
1860 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
1861 &weight_op[5], &weight_avg[5],
1862 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1863 }else{
1864 int j;
1865 assert(IS_SUB_4X4(sub_mb_type));
1866 for(j=0; j<4; j++){
1867 int sub_x_offset= x_offset + 2*(j&1);
1868 int sub_y_offset= y_offset + (j&2);
1869 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
1870 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
1871 &weight_op[6], &weight_avg[6],
1872 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
1873 }
1874 }
1875 }
1876 }
1877
1878 prefetch_motion(h, 1);
1879 }
1880
1881 static av_cold void init_cavlc_level_tab(void){
1882 int suffix_length, mask;
1883 unsigned int i;
1884
1885 for(suffix_length=0; suffix_length<7; suffix_length++){
1886 for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
1887 int prefix= LEVEL_TAB_BITS - av_log2(2*i);
1888 int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);
1889
1890 mask= -(level_code&1);
1891 level_code= (((2+level_code)>>1) ^ mask) - mask;
1892 if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
1893 cavlc_level_tab[suffix_length][i][0]= level_code;
1894 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
1895 }else if(prefix + 1 <= LEVEL_TAB_BITS){
1896 cavlc_level_tab[suffix_length][i][0]= prefix+100;
1897 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
1898 }else{
1899 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
1900 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
1901 }
1902 }
1903 }
1904 }
1905
1906 static av_cold void decode_init_vlc(void){
1907 static int done = 0;
1908
1909 if (!done) {
1910 int i;
1911 int offset;
1912 done = 1;
1913
1914 chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
1915 chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
1916 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
1917 &chroma_dc_coeff_token_len [0], 1, 1,
1918 &chroma_dc_coeff_token_bits[0], 1, 1,
1919 INIT_VLC_USE_NEW_STATIC);
1920
1921 offset = 0;
1922 for(i=0; i<4; i++){
1923 coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
1924 coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
1925 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
1926 &coeff_token_len [i][0], 1, 1,
1927 &coeff_token_bits[i][0], 1, 1,
1928 INIT_VLC_USE_NEW_STATIC);
1929 offset += coeff_token_vlc_tables_size[i];
1930 }
1931 /*
1932 * This is a one time safety check to make sure that
1933 * the packed static coeff_token_vlc table sizes
1934 * were initialized correctly.
1935 */
1936 assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
1937
1938 for(i=0; i<3; i++){
1939 chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
1940 chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
1941 init_vlc(&chroma_dc_total_zeros_vlc[i],
1942 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
1943 &chroma_dc_total_zeros_len [i][0], 1, 1,
1944 &chroma_dc_total_zeros_bits[i][0], 1, 1,
1945 INIT_VLC_USE_NEW_STATIC);
1946 }
1947 for(i=0; i<15; i++){
1948 total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
1949 total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
1950 init_vlc(&total_zeros_vlc[i],
1951 TOTAL_ZEROS_VLC_BITS, 16,
1952 &total_zeros_len [i][0], 1, 1,
1953 &total_zeros_bits[i][0], 1, 1,
1954 INIT_VLC_USE_NEW_STATIC);
1955 }
1956
1957 for(i=0; i<6; i++){
1958 run_vlc[i].table = run_vlc_tables[i];
1959 run_vlc[i].table_allocated = run_vlc_tables_size;
1960 init_vlc(&run_vlc[i],
1961 RUN_VLC_BITS, 7,
1962 &run_len [i][0], 1, 1,
1963 &run_bits[i][0], 1, 1,
1964 INIT_VLC_USE_NEW_STATIC);
1965 }
1966 run7_vlc.table = run7_vlc_table,
1967 run7_vlc.table_allocated = run7_vlc_table_size;
1968 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
1969 &run_len [6][0], 1, 1,
1970 &run_bits[6][0], 1, 1,
1971 INIT_VLC_USE_NEW_STATIC);
1972
1973 init_cavlc_level_tab();
1974 }
1975 }
1976
1977 static void free_tables(H264Context *h){
1978 int i;
1979 H264Context *hx;
1980 av_freep(&h->intra4x4_pred_mode);
1981 av_freep(&h->chroma_pred_mode_table);
1982 av_freep(&h->cbp_table);
1983 av_freep(&h->mvd_table[0]);
1984 av_freep(&h->mvd_table[1]);
1985 av_freep(&h->direct_table);
1986 av_freep(&h->non_zero_count);
1987 av_freep(&h->slice_table_base);
1988 h->slice_table= NULL;
1989
1990 av_freep(&h->mb2b_xy);
1991 av_freep(&h->mb2b8_xy);
1992
1993 for(i = 0; i < h->s.avctx->thread_count; i++) {
1994 hx = h->thread_context[i];
1995 if(!hx) continue;
1996 av_freep(&hx->top_borders[1]);
1997 av_freep(&hx->top_borders[0]);
1998 av_freep(&hx->s.obmc_scratchpad);
1999 }
2000 }
2001
2002 static void init_dequant8_coeff_table(H264Context *h){
2003 int i,q,x;
2004 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
2005 h->dequant8_coeff[0] = h->dequant8_buffer[0];
2006 h->dequant8_coeff[1] = h->dequant8_buffer[1];
2007
2008 for(i=0; i<2; i++ ){
2009 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
2010 h->dequant8_coeff[1] = h->dequant8_buffer[0];
2011 break;
2012 }
2013
2014 for(q=0; q<52; q++){
2015 int shift = div6[q];
2016 int idx = rem6[q];
2017 for(x=0; x<64; x++)
2018 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
2019 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
2020 h->pps.scaling_matrix8[i][x]) << shift;
2021 }
2022 }
2023 }
2024
2025 static void init_dequant4_coeff_table(H264Context *h){
2026 int i,j,q,x;
2027 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
2028 for(i=0; i<6; i++ ){
2029 h->dequant4_coeff[i] = h->dequant4_buffer[i];
2030 for(j=0; j<i; j++){
2031 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
2032 h->dequant4_coeff[i] = h->dequant4_buffer[j];
2033 break;
2034 }
2035 }
2036 if(j<i)
2037 continue;
2038
2039 for(q=0; q<52; q++){
2040 int shift = div6[q] + 2;
2041 int idx = rem6[q];
2042 for(x=0; x<16; x++)
2043 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
2044 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
2045 h->pps.scaling_matrix4[i][x]) << shift;
2046 }
2047 }
2048 }
2049
2050 static void init_dequant_tables(H264Context *h){
2051 int i,x;
2052 init_dequant4_coeff_table(h);
2053 if(h->pps.transform_8x8_mode)
2054 init_dequant8_coeff_table(h);
2055 if(h->sps.transform_bypass){
2056 for(i=0; i<6; i++)
2057 for(x=0; x<16; x++)
2058 h->dequant4_coeff[i][0][x] = 1<<6;
2059 if(h->pps.transform_8x8_mode)
2060 for(i=0; i<2; i++)
2061 for(x=0; x<64; x++)
2062 h->dequant8_coeff[i][0][x] = 1<<6;
2063 }
2064 }
2065
2066
2067 /**
2068 * allocates tables.
2069 * needs width/height
2070 */
2071 static int alloc_tables(H264Context *h){
2072 MpegEncContext * const s = &h->s;
2073 const int big_mb_num= s->mb_stride * (s->mb_height+1);
2074 int x,y;
2075
2076 CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t))
2077
2078 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t))
2079 CHECKED_ALLOCZ(h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base))
2080 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
2081
2082 CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
2083 CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
2084 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
2085 CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
2086
2087 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base));
2088 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
2089
2090 CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint32_t));
2091 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
2092 for(y=0; y<s->mb_height; y++){
2093 for(x=0; x<s->mb_width; x++){
2094 const int mb_xy= x + y*s->mb_stride;
2095 const int b_xy = 4*x + 4*y*h->b_stride;
2096 const int b8_xy= 2*x + 2*y*h->b8_stride;
2097
2098 h->mb2b_xy [mb_xy]= b_xy;
2099 h->mb2b8_xy[mb_xy]= b8_xy;
2100 }
2101 }
2102
2103 s->obmc_scratchpad = NULL;
2104
2105 if(!h->dequant4_coeff[0])
2106 init_dequant_tables(h);
2107
2108 return 0;
2109 fail:
2110 free_tables(h);
2111 return -1;
2112 }
2113
2114 /**
2115 * Mimic alloc_tables(), but for every context thread.
2116 */
2117 static void clone_tables(H264Context *dst, H264Context *src){
2118 dst->intra4x4_pred_mode = src->intra4x4_pred_mode;
2119 dst->non_zero_count = src->non_zero_count;
2120 dst->slice_table = src->slice_table;
2121 dst->cbp_table = src->cbp_table;
2122 dst->mb2b_xy = src->mb2b_xy;
2123 dst->mb2b8_xy = src->mb2b8_xy;
2124 dst->chroma_pred_mode_table = src->chroma_pred_mode_table;
2125 dst->mvd_table[0] = src->mvd_table[0];
2126 dst->mvd_table[1] = src->mvd_table[1];
2127 dst->direct_table = src->direct_table;
2128
2129 dst->s.obmc_scratchpad = NULL;
2130 ff_h264_pred_init(&dst->hpc, src->s.codec_id);
2131 }
2132
2133 /**
2134 * Init context
2135 * Allocate buffers which are not shared amongst multiple threads.
2136 */
2137 static int context_init(H264Context *h){
2138 CHECKED_ALLOCZ(h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t))
2139 CHECKED_ALLOCZ(h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t))
2140
2141 return 0;
2142 fail:
2143 return -1; // free_tables will clean up for us
2144 }
2145
2146 static av_cold void common_init(H264Context *h){
2147 MpegEncContext * const s = &h->s;
2148
2149 s->width = s->avctx->width;
2150 s->height = s->avctx->height;
2151 s->codec_id= s->avctx->codec->id;
2152
2153 ff_h264_pred_init(&h->hpc, s->codec_id);
2154
2155 h->dequant_coeff_pps= -1;
2156 s->unrestricted_mv=1;
2157 s->decode=1; //FIXME
2158
2159 dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
2160
2161 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
2162 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
2163 }
2164
2165 static av_cold int decode_init(AVCodecContext *avctx){
2166 H264Context *h= avctx->priv_data;
2167 MpegEncContext * const s = &h->s;
2168
2169 MPV_decode_defaults(s);
2170
2171 s->avctx = avctx;
2172 common_init(h);
2173
2174 s->out_format = FMT_H264;
2175 s->workaround_bugs= avctx->workaround_bugs;
2176
2177 // set defaults
2178 // s->decode_mb= ff_h263_decode_mb;
2179 s->quarter_sample = 1;
2180 s->low_delay= 1;
2181
2182 if(avctx->codec_id == CODEC_ID_SVQ3)
2183 avctx->pix_fmt= PIX_FMT_YUVJ420P;
2184 else
2185 avctx->pix_fmt= PIX_FMT_YUV420P;
2186
2187 decode_init_vlc();
2188
2189 if(avctx->extradata_size > 0 && avctx->extradata &&
2190 *(char *)avctx->extradata == 1){
2191 h->is_avc = 1;
2192 h->got_avcC = 0;
2193 } else {
2194 h->is_avc = 0;
2195 }
2196
2197 h->thread_context[0] = h;
2198 h->outputed_poc = INT_MIN;
2199 h->prev_poc_msb= 1<<16;
2200 return 0;
2201 }
2202
2203 static int frame_start(H264Context *h){
2204 MpegEncContext * const s = &h->s;
2205 int i;
2206
2207 if(MPV_frame_start(s, s->avctx) < 0)
2208 return -1;
2209 ff_er_frame_start(s);
2210 /*
2211 * MPV_frame_start uses pict_type to derive key_frame.
2212 * This is incorrect for H.264; IDR markings must be used.
2213 * Zero here; IDR markings per slice in frame or fields are ORed in later.
2214 * See decode_nal_units().
2215 */
2216 s->current_picture_ptr->key_frame= 0;
2217
2218 assert(s->linesize && s->uvlinesize);
2219
2220 for(i=0; i<16; i++){
2221 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
2222 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
2223 }
2224 for(i=0; i<4; i++){
2225 h->block_offset[16+i]=
2226 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2227 h->block_offset[24+16+i]=
2228 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2229 }
2230
2231 /* can't be in alloc_tables because linesize isn't known there.
2232 * FIXME: redo bipred weight to not require extra buffer? */
2233 for(i = 0; i < s->avctx->thread_count; i++)
2234 if(!h->thread_context[i]->s.obmc_scratchpad)
2235 h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
2236
2237 /* some macroblocks will be accessed before they're available */
2238 if(FRAME_MBAFF || s->avctx->thread_count > 1)
2239 memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
2240
2241 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
2242
2243 // We mark the current picture as non-reference after allocating it, so
2244 // that if we break out due to an error it can be released automatically
2245 // in the next MPV_frame_start().
2246 // SVQ3 as well as most other codecs have only last/next/current and thus
2247 // get released even with set reference, besides SVQ3 and others do not
2248 // mark frames as reference later "naturally".
2249 if(s->codec_id != CODEC_ID_SVQ3)
2250 s->current_picture_ptr->reference= 0;
2251
2252 s->current_picture_ptr->field_poc[0]=
2253 s->current_picture_ptr->field_poc[1]= INT_MAX;
2254 assert(s->current_picture_ptr->long_ref==0);
2255
2256 return 0;
2257 }
2258
2259 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){
2260 MpegEncContext * const s = &h->s;
2261 int i;
2262 int step = 1;
2263 int offset = 1;
2264 int uvoffset= 1;
2265 int top_idx = 1;
2266 int skiplast= 0;
2267
2268 src_y -= linesize;
2269 src_cb -= uvlinesize;
2270 src_cr -= uvlinesize;
2271
2272 if(!simple && FRAME_MBAFF){
2273 if(s->mb_y&1){
2274 offset = MB_MBAFF ? 1 : 17;
2275 uvoffset= MB_MBAFF ? 1 : 9;
2276 if(!MB_MBAFF){
2277 *(uint64_t*)(h->top_borders[0][s->mb_x]+ 0)= *(uint64_t*)(src_y + 15*linesize);
2278 *(uint64_t*)(h->top_borders[0][s->mb_x]+ 8)= *(uint64_t*)(src_y +8+15*linesize);
2279 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2280 *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+7*uvlinesize);
2281 *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+7*uvlinesize);
2282 }
2283 }
2284 }else{
2285 if(!MB_MBAFF){
2286 h->left_border[0]= h->top_borders[0][s->mb_x][15];
2287 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2288 h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7 ];
2289 h->left_border[34+18]= h->top_borders[0][s->mb_x][16+8+7];
2290 }
2291 skiplast= 1;
2292 }
2293 offset =
2294 uvoffset=
2295 top_idx = MB_MBAFF ? 0 : 1;
2296 }
2297 step= MB_MBAFF ? 2 : 1;
2298 }
2299
2300 // There are two lines saved, the line above the the top macroblock of a pair,
2301 // and the line above the bottom macroblock
2302 h->left_border[offset]= h->top_borders[top_idx][s->mb_x][15];
2303 for(i=1; i<17 - skiplast; i++){
2304 h->left_border[offset+i*step]= src_y[15+i* linesize];
2305 }
2306
2307 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize);
2308 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
2309
2310 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2311 h->left_border[uvoffset+34 ]= h->top_borders[top_idx][s->mb_x][16+7];
2312 h->left_border[uvoffset+34+18]= h->top_borders[top_idx][s->mb_x][24+7];
2313 for(i=1; i<9 - skiplast; i++){
2314 h->left_border[uvoffset+34 +i*step]= src_cb[7+i*uvlinesize];
2315 h->left_border[uvoffset+34+18+i*step]= src_cr[7+i*uvlinesize];
2316 }
2317 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
2318 *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
2319 }
2320 }
2321
2322 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){
2323 MpegEncContext * const s = &h->s;
2324 int temp8, i;
2325 uint64_t temp64;
2326 int deblock_left;
2327 int deblock_top;
2328 int mb_xy;
2329 int step = 1;
2330 int offset = 1;
2331 int uvoffset= 1;
2332 int top_idx = 1;
2333
2334 if(!simple && FRAME_MBAFF){
2335 if(s->mb_y&1){
2336 offset = MB_MBAFF ? 1 : 17;
2337 uvoffset= MB_MBAFF ? 1 : 9;
2338 }else{
2339 offset =
2340 uvoffset=
2341 top_idx = MB_MBAFF ? 0 : 1;
2342 }
2343 step= MB_MBAFF ? 2 : 1;
2344 }
2345
2346 if(h->deblocking_filter == 2) {
2347 mb_xy = h->mb_xy;
2348 deblock_left = h->slice_table[mb_xy] == h->slice_table[mb_xy - 1];
2349 deblock_top = h->slice_table[mb_xy] == h->slice_table[h->top_mb_xy];
2350 } else {
2351 deblock_left = (s->mb_x > 0);
2352 deblock_top = (s->mb_y > !!MB_FIELD);
2353 }
2354
2355 src_y -= linesize + 1;
2356 src_cb -= uvlinesize + 1;
2357 src_cr -= uvlinesize + 1;
2358
2359 #define XCHG(a,b,t,xchg)\
2360 t= a;\
2361 if(xchg)\
2362 a= b;\
2363 b= t;
2364
2365 if(deblock_left){
2366 for(i = !deblock_top; i<16; i++){
2367 XCHG(h->left_border[offset+i*step], src_y [i* linesize], temp8, xchg);
2368 }
2369 XCHG(h->left_border[offset+i*step], src_y [i* linesize], temp8, 1);
2370 }
2371
2372 if(deblock_top){
2373 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
2374 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
2375 if(s->mb_x+1 < s->mb_width){
2376 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
2377 }
2378 }
2379
2380 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2381 if(deblock_left){
2382 for(i = !deblock_top; i<8; i++){
2383 XCHG(h->left_border[uvoffset+34 +i*step], src_cb[i*uvlinesize], temp8, xchg);
2384 XCHG(h->left_border[uvoffset+34+18+i*step], src_cr[i*uvlinesize], temp8, xchg);
2385 }
2386 XCHG(h->left_border[uvoffset+34 +i*step], src_cb[i*uvlinesize], temp8, 1);
2387 XCHG(h->left_border[uvoffset+34+18+i*step], src_cr[i*uvlinesize], temp8, 1);
2388 }
2389 if(deblock_top){
2390 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
2391 XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
2392 }
2393 }
2394 }
2395
2396 static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){
2397 MpegEncContext * const s = &h->s;
2398 const int mb_x= s->mb_x;
2399 const int mb_y= s->mb_y;
2400 const int mb_xy= h->mb_xy;
2401 const int mb_type= s->current_picture.mb_type[mb_xy];
2402 uint8_t *dest_y, *dest_cb, *dest_cr;
2403 int linesize, uvlinesize /*dct_offset*/;
2404 int i;
2405 int *block_offset = &h->block_offset[0];
2406 const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
2407 const int is_h264 = simple || s->codec_id == CODEC_ID_H264;
2408 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
2409 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
2410
2411 dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
2412 dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
2413 dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
2414
2415 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
2416 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);
2417
2418 if (!simple && MB_FIELD) {
2419 linesize = h->mb_linesize = s->linesize * 2;
2420 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
2421 block_offset = &h->block_offset[24];
2422 if(mb_y&1){ //FIXME move out of this function?
2423 dest_y -= s->linesize*15;
2424 dest_cb-= s->uvlinesize*7;
2425 dest_cr-= s->uvlinesize*7;
2426 }
2427 if(FRAME_MBAFF) {
2428 int list;
2429 for(list=0; list<h->list_count; list++){
2430 if(!USES_LIST(mb_type, list))
2431 continue;
2432 if(IS_16X16(mb_type)){
2433 int8_t *ref = &h->ref_cache[list][scan8[0]];
2434 fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
2435 }else{
2436 for(i=0; i<16; i+=4){
2437 int ref = h->ref_cache[list][scan8[i]];
2438 if(ref >= 0)
2439 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
2440 }
2441 }
2442 }
2443 }
2444 } else {
2445 linesize = h->mb_linesize = s->linesize;
2446 uvlinesize = h->mb_uvlinesize = s->uvlinesize;
2447 // dct_offset = s->linesize * 16;
2448 }
2449
2450 if (!simple && IS_INTRA_PCM(mb_type)) {
2451 for (i=0; i<16; i++) {
2452 memcpy(dest_y + i* linesize, h->mb + i*8, 16);
2453 }
2454 for (i=0; i<8; i++) {
2455 memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4, 8);
2456 memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4, 8);
2457 }
2458 } else {
2459 if(IS_INTRA(mb_type)){
2460 if(h->deblocking_filter)
2461 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
2462
2463 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2464 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
2465 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
2466 }
2467
2468 if(IS_INTRA4x4(mb_type)){
2469 if(simple || !s->encoding){
2470 if(IS_8x8DCT(mb_type)){
2471 if(transform_bypass){
2472 idct_dc_add =
2473 idct_add = s->dsp.add_pixels8;
2474 }else{
2475 idct_dc_add = s->dsp.h264_idct8_dc_add;
2476 idct_add = s->dsp.h264_idct8_add;
2477 }
2478 for(i=0; i<16; i+=4){
2479 uint8_t * const ptr= dest_y + block_offset[i];
2480 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2481 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
2482 h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);
2483 }else{
2484 const int nnz = h->non_zero_count_cache[ scan8[i] ];
2485 h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
2486 (h->topright_samples_available<<i)&0x4000, linesize);
2487 if(nnz){
2488 if(nnz == 1 && h->mb[i*16])
2489 idct_dc_add(ptr, h->mb + i*16, linesize);
2490 else
2491 idct_add (ptr, h->mb + i*16, linesize);
2492 }
2493 }
2494 }
2495 }else{
2496 if(transform_bypass){
2497 idct_dc_add =
2498 idct_add = s->dsp.add_pixels4;
2499 }else{
2500 idct_dc_add = s->dsp.h264_idct_dc_add;
2501 idct_add = s->dsp.h264_idct_add;
2502 }
2503 for(i=0; i<16; i++){
2504 uint8_t * const ptr= dest_y + block_offset[i];
2505 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
2506
2507 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
2508 h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
2509 }else{
2510 uint8_t *topright;
2511 int nnz, tr;
2512 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
2513 const int topright_avail= (h->topright_samples_available<<i)&0x8000;
2514 assert(mb_y || linesize <= block_offset[i]);
2515 if(!topright_avail){
2516 tr= ptr[3 - linesize]*0x01010101;
2517 topright= (uint8_t*) &tr;
2518 }else
2519 topright= ptr + 4 - linesize;
2520 }else
2521 topright= NULL;
2522
2523 h->hpc.pred4x4[ dir ](ptr, topright, linesize);
2524 nnz = h->non_zero_count_cache[ scan8[i] ];
2525 if(nnz){
2526 if(is_h264){
2527 if(nnz == 1 && h->mb[i*16])
2528 idct_dc_add(ptr, h->mb + i*16, linesize);
2529 else
2530 idct_add (ptr, h->mb + i*16, linesize);
2531 }else
2532 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
2533 }
2534 }
2535 }
2536 }
2537 }
2538 }else{
2539 h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
2540 if(is_h264){
2541 if(!transform_bypass)
2542 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]);
2543 }else
2544 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
2545 }
2546 if(h->deblocking_filter)
2547 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);
2548 }else if(is_h264){
2549 hl_motion(h, dest_y, dest_cb, dest_cr,
2550 s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
2551 s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
2552 s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
2553 }
2554
2555
2556 if(!IS_INTRA4x4(mb_type)){
2557 if(is_h264){
2558 if(IS_INTRA16x16(mb_type)){
2559 if(transform_bypass){
2560 if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
2561 h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
2562 }else{
2563 for(i=0; i<16; i++){
2564 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2565 s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize);
2566 }
2567 }
2568 }else{
2569 s->dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2570 }
2571 }else if(h->cbp&15){
2572 if(transform_bypass){
2573 const int di = IS_8x8DCT(mb_type) ? 4 : 1;
2574 idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
2575 for(i=0; i<16; i+=di){
2576 if(h->non_zero_count_cache[ scan8[i] ]){
2577 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
2578 }
2579 }
2580 }else{
2581 if(IS_8x8DCT(mb_type)){
2582 s->dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2583 }else{
2584 s->dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2585 }
2586 }
2587 }
2588 }else{
2589 for(i=0; i<16; i++){
2590 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
2591 uint8_t * const ptr= dest_y + block_offset[i];
2592 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
2593 }
2594 }
2595 }
2596 }
2597
2598 if((simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
2599 uint8_t *dest[2] = {dest_cb, dest_cr};
2600 if(transform_bypass){
2601 if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
2602 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize);
2603 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize);
2604 }else{
2605 idct_add = s->dsp.add_pixels4;
2606 for(i=16; i<16+8; i++){
2607 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2608 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2609 }
2610 }
2611 }else{
2612 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]);
2613 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]);
2614 if(is_h264){
2615 idct_add = s->dsp.h264_idct_add;
2616 idct_dc_add = s->dsp.h264_idct_dc_add;
2617 for(i=16; i<16+8; i++){
2618 if(h->non_zero_count_cache[ scan8[i] ])
2619 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2620 else if(h->mb[i*16])
2621 idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
2622 }
2623 }else{
2624 for(i=16; i<16+8; i++){
2625 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2626 uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
2627 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
2628 }
2629 }
2630 }
2631 }
2632 }
2633 }
2634 if(h->cbp || IS_INTRA(mb_type))
2635 s->dsp.clear_blocks(h->mb);
2636
2637 if(h->deblocking_filter) {
2638 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, simple);
2639 fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
2640 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
2641 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
2642 if (!simple && FRAME_MBAFF) {
2643 filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2644 } else {
2645 filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2646 }
2647 }
2648 }
2649
2650 /**
2651 * Process a macroblock; this case avoids checks for expensive uncommon cases.
2652 */
2653 static void hl_decode_mb_simple(H264Context *h){
2654 hl_decode_mb_internal(h, 1);
2655 }
2656
2657 /**
2658 * Process a macroblock; this handles edge cases, such as interlacing.
2659 */
2660 static void av_noinline hl_decode_mb_complex(H264Context *h){
2661 hl_decode_mb_internal(h, 0);
2662 }
2663
2664 static void hl_decode_mb(H264Context *h){
2665 MpegEncContext * const s = &h->s;
2666 const int mb_xy= h->mb_xy;
2667 const int mb_type= s->current_picture.mb_type[mb_xy];
2668 int is_complex = ENABLE_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
2669
2670 if(ENABLE_H264_ENCODER && !s->decode)
2671 return;
2672
2673 if (is_complex)
2674 hl_decode_mb_complex(h);
2675 else hl_decode_mb_simple(h);
2676 }
2677
2678 static void pic_as_field(Picture *pic, const int parity){
2679 int i;
2680 for (i = 0; i < 4; ++i) {
2681 if (parity == PICT_BOTTOM_FIELD)
2682 pic->data[i] += pic->linesize[i];
2683 pic->reference = parity;
2684 pic->linesize[i] *= 2;
2685 }
2686 pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD];
2687 }
2688
2689 static int split_field_copy(Picture *dest, Picture *src,
2690 int parity, int id_add){
2691 int match = !!(src->reference & parity);
2692
2693 if (match) {
2694 *dest = *src;
2695 if(parity != PICT_FRAME){
2696 pic_as_field(dest, parity);
2697 dest->pic_id *= 2;
2698 dest->pic_id += id_add;
2699 }
2700 }
2701
2702 return match;
2703 }
2704
2705 static int build_def_list(Picture *def, Picture **in, int len, int is_long, int sel){
2706 int i[2]={0};
2707 int index=0;
2708
2709 while(i[0]<len || i[1]<len){
2710 while(i[0]<len && !(in[ i[0] ] && (in[ i[0] ]->reference & sel)))
2711 i[0]++;
2712 while(i[1]<len && !(in[ i[1] ] && (in[ i[1] ]->reference & (sel^3))))
2713 i[1]++;
2714 if(i[0] < len){
2715 in[ i[0] ]->pic_id= is_long ? i[0] : in[ i[0] ]->frame_num;
2716 split_field_copy(&def[index++], in[ i[0]++ ], sel , 1);
2717 }
2718 if(i[1] < len){
2719 in[ i[1] ]->pic_id= is_long ? i[1] : in[ i[1] ]->frame_num;
2720 split_field_copy(&def[index++], in[ i[1]++ ], sel^3, 0);
2721 }
2722 }
2723
2724 return index;
2725 }
2726
2727 static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir){
2728 int i, best_poc;
2729 int out_i= 0;
2730
2731 for(;;){
2732 best_poc= dir ? INT_MIN : INT_MAX;
2733
2734 for(i=0; i<len; i++){
2735 const int poc= src[i]->poc;
2736 if(((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)){
2737 best_poc= poc;
2738 sorted[out_i]= src[i];
2739 }
2740 }
2741 if(best_poc == (dir ? INT_MIN : INT_MAX))
2742 break;
2743 limit= sorted[out_i++]->poc - dir;
2744 }
2745 return out_i;
2746 }
2747
2748 /**
2749 * fills the default_ref_list.
2750 */
2751 static int fill_default_ref_list(H264Context *h){
2752 MpegEncContext * const s = &h->s;
2753 int i, len;
2754
2755 if(h->slice_type_nos==FF_B_TYPE){
2756 Picture *sorted[32];
2757 int cur_poc, list;
2758 int lens[2];
2759
2760 if(FIELD_PICTURE)
2761 cur_poc= s->current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
2762 else
2763 cur_poc= s->current_picture_ptr->poc;
2764
2765 for(list= 0; list<2; list++){
2766 len= add_sorted(sorted , h->short_ref, h->short_ref_count, cur_poc, 1^list);
2767 len+=add_sorted(sorted+len, h->short_ref, h->short_ref_count, cur_poc, 0^list);
2768 assert(len<=32);
2769 len= build_def_list(h->default_ref_list[list] , sorted , len, 0, s->picture_structure);
2770 len+=build_def_list(h->default_ref_list[list]+len, h->long_ref, 16 , 1, s->picture_structure);
2771 assert(len<=32);
2772
2773 if(len < h->ref_count[list])
2774 memset(&h->default_ref_list[list][len], 0, sizeof(Picture)*(h->ref_count[list] - len));
2775 lens[list]= len;
2776 }
2777
2778 if(lens[0] == lens[1] && lens[1] > 1){
2779 for(i=0; h->default_ref_list[0][i].data[0] == h->default_ref_list[1][i].data[0] && i<lens[0]; i++);
2780 if(i == lens[0])
2781 FFSWAP(Picture, h->default_ref_list[1][0], h->default_ref_list[1][1]);
2782 }
2783 }else{
2784 len = build_def_list(h->default_ref_list[0] , h->short_ref, h->short_ref_count, 0, s->picture_structure);
2785 len+= build_def_list(h->default_ref_list[0]+len, h-> long_ref, 16 , 1, s->picture_structure);
2786 assert(len <= 32);
2787 if(len < h->ref_count[0])
2788 memset(&h->default_ref_list[0][len], 0, sizeof(Picture)*(h->ref_count[0] - len));
2789 }
2790 #ifdef TRACE
2791 for (i=0; i<h->ref_count[0]; i++) {
2792 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]);
2793 }
2794 if(h->slice_type_nos==FF_B_TYPE){
2795 for (i=0; i<h->ref_count[1]; i++) {
2796 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]);
2797 }
2798 }
2799 #endif
2800 return 0;
2801 }
2802
2803 static void print_short_term(H264Context *h);
2804 static void print_long_term(H264Context *h);
2805
2806 /**
2807 * Extract structure information about the picture described by pic_num in
2808 * the current decoding context (frame or field). Note that pic_num is
2809 * picture number without wrapping (so, 0<=pic_num<max_pic_num).
2810 * @param pic_num picture number for which to extract structure information
2811 * @param structure one of PICT_XXX describing structure of picture
2812 * with pic_num
2813 * @return frame number (short term) or long term index of picture
2814 * described by pic_num
2815 */
2816 static int pic_num_extract(H264Context *h, int pic_num, int *structure){
2817 MpegEncContext * const s = &h->s;
2818
2819 *structure = s->picture_structure;
2820 if(FIELD_PICTURE){
2821 if (!(pic_num & 1))
2822 /* opposite field */
2823 *structure ^= PICT_FRAME;
2824 pic_num >>= 1;
2825 }
2826
2827 return pic_num;
2828 }
2829
2830 static int decode_ref_pic_list_reordering(H264Context *h){
2831 MpegEncContext * const s = &h->s;
2832 int list, index, pic_structure;
2833
2834 print_short_term(h);
2835 print_long_term(h);
2836
2837 for(list=0; list<h->list_count; list++){
2838 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
2839
2840 if(get_bits1(&s->gb)){
2841 int pred= h->curr_pic_num;
2842
2843 for(index=0; ; index++){
2844 unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
2845 unsigned int pic_id;
2846 int i;
2847 Picture *ref = NULL;
2848
2849 if(reordering_of_pic_nums_idc==3)
2850 break;
2851
2852 if(index >= h->ref_count[list]){
2853 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
2854 return -1;
2855 }
2856
2857 if(reordering_of_pic_nums_idc<3){
2858 if(reordering_of_pic_nums_idc<2){
2859 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
2860 int frame_num;
2861
2862 if(abs_diff_pic_num > h->max_pic_num){
2863 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
2864 return -1;
2865 }
2866
2867 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
2868 else pred+= abs_diff_pic_num;
2869 pred &= h->max_pic_num - 1;
2870
2871 frame_num = pic_num_extract(h, pred, &pic_structure);
2872
2873 for(i= h->short_ref_count-1; i>=0; i--){
2874 ref = h->short_ref[i];