Move aspect ratio 0/0 avoidance code so the values in the sps struct are not missed.
[libav.git] / libavcodec / h264.c
CommitLineData
0da71265
MN
1/*
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
0da71265
MN
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
0da71265 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
0da71265
MN
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
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
0da71265 20 */
115329f1 21
0da71265 22/**
ba87f080 23 * @file
0da71265
MN
24 * H.264 / AVC / MPEG4 part10 codec.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
e2983d6e 28#include "libavcore/imgutils.h"
40e5d31b 29#include "internal.h"
0da71265
MN
30#include "dsputil.h"
31#include "avcodec.h"
32#include "mpegvideo.h"
26b4fe82 33#include "h264.h"
0da71265 34#include "h264data.h"
188d3c51 35#include "h264_mvpred.h"
26b4fe82 36#include "h264_parser.h"
0da71265 37#include "golomb.h"
199436b9 38#include "mathops.h"
626464fb 39#include "rectangle.h"
369122dd 40#include "vdpau_internal.h"
cfa5a81e 41#include "libavutil/avassert.h"
0da71265 42
e5017ab8
LA
43#include "cabac.h"
44
2848ce84 45//#undef NDEBUG
0da71265
MN
46#include <assert.h>
47
d9ec210b 48static const uint8_t rem6[52]={
acd8d10f
PI
490, 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,
50};
51
d9ec210b 52static const uint8_t div6[52]={
acd8d10f
PI
530, 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,
54};
55
0435fb16
BC
56static const enum PixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = {
57 PIX_FMT_DXVA2_VLD,
58 PIX_FMT_VAAPI_VLD,
59 PIX_FMT_YUVJ420P,
60 PIX_FMT_NONE
61};
62
903d58f6 63void ff_h264_write_back_intra_pred_mode(H264Context *h){
5b0fb524 64 int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
0da71265 65
662a5b23
MN
66 AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
67 mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
68 mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
69 mode[6]= h->intra4x4_pred_mode_cache[7+8*1];
0da71265
MN
70}
71
72/**
73 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
74 */
2bedc0e8
MN
75int ff_h264_check_intra4x4_pred_mode(H264Context *h){
76 MpegEncContext * const s = &h->s;
77 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
78 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
79 int i;
80
81 if(!(h->top_samples_available&0x8000)){
82 for(i=0; i<4; i++){
83 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
84 if(status<0){
85 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);
86 return -1;
87 } else if(status){
88 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
89 }
90 }
91 }
92
93 if((h->left_samples_available&0x8888)!=0x8888){
94 static const int mask[4]={0x8000,0x2000,0x80,0x20};
95 for(i=0; i<4; i++){
96 if(!(h->left_samples_available&mask[i])){
97 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
98 if(status<0){
99 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);
100 return -1;
101 } else if(status){
102 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
103 }
104 }
105 }
106 }
107
108 return 0;
109} //FIXME cleanup like ff_h264_check_intra_pred_mode
110
111/**
112 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
113 */
903d58f6 114int ff_h264_check_intra_pred_mode(H264Context *h, int mode){
0da71265
MN
115 MpegEncContext * const s = &h->s;
116 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
117 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
115329f1 118
43ff0714 119 if(mode > 6U) {
5175b937 120 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);
7440fe83 121 return -1;
5175b937 122 }
115329f1 123
0da71265
MN
124 if(!(h->top_samples_available&0x8000)){
125 mode= top[ mode ];
126 if(mode<0){
9b879566 127 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);
0da71265
MN
128 return -1;
129 }
130 }
115329f1 131
d1d10e91 132 if((h->left_samples_available&0x8080) != 0x8080){
0da71265 133 mode= left[ mode ];
d1d10e91
MN
134 if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
135 mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
136 }
0da71265 137 if(mode<0){
9b879566 138 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);
0da71265 139 return -1;
115329f1 140 }
0da71265
MN
141 }
142
143 return mode;
144}
145
1790a5e9 146const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
0da71265
MN
147 int i, si, di;
148 uint8_t *dst;
24456882 149 int bufidx;
0da71265 150
bb270c08 151// src[0]&0x80; //forbidden bit
0da71265
MN
152 h->nal_ref_idc= src[0]>>5;
153 h->nal_unit_type= src[0]&0x1F;
154
155 src++; length--;
115329f1 156#if 0
0da71265
MN
157 for(i=0; i<length; i++)
158 printf("%2X ", src[i]);
159#endif
e08715d3 160
b250f9c6
AJ
161#if HAVE_FAST_UNALIGNED
162# if HAVE_FAST_64BIT
e08715d3
MN
163# define RS 7
164 for(i=0; i+1<length; i+=9){
19769ece 165 if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))
e08715d3
MN
166# else
167# define RS 3
168 for(i=0; i+1<length; i+=5){
19769ece 169 if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U))
e08715d3
MN
170# endif
171 continue;
172 if(i>0 && !src[i]) i--;
173 while(src[i]) i++;
174#else
175# define RS 0
0da71265
MN
176 for(i=0; i+1<length; i+=2){
177 if(src[i]) continue;
178 if(i>0 && src[i-1]==0) i--;
e08715d3 179#endif
0da71265
MN
180 if(i+2<length && src[i+1]==0 && src[i+2]<=3){
181 if(src[i+2]!=3){
182 /* startcode, so we must be past the end */
183 length=i;
184 }
185 break;
186 }
abb27cfb 187 i-= RS;
0da71265
MN
188 }
189
190 if(i>=length-1){ //no escaped 0
191 *dst_length= length;
192 *consumed= length+1; //+1 for the header
115329f1 193 return src;
0da71265
MN
194 }
195
24456882 196 bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
238ef6da 197 av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
24456882 198 dst= h->rbsp_buffer[bufidx];
0da71265 199
ac658be5
FOL
200 if (dst == NULL){
201 return NULL;
202 }
203
3b66c4c5 204//printf("decoding esc\n");
593af7cd
MN
205 memcpy(dst, src, i);
206 si=di=i;
207 while(si+2<length){
0da71265 208 //remove escapes (very rare 1:2^22)
593af7cd
MN
209 if(src[si+2]>3){
210 dst[di++]= src[si++];
211 dst[di++]= src[si++];
212 }else if(src[si]==0 && src[si+1]==0){
0da71265
MN
213 if(src[si+2]==3){ //escape
214 dst[di++]= 0;
215 dst[di++]= 0;
216 si+=3;
c8470cc1 217 continue;
0da71265 218 }else //next start code
593af7cd 219 goto nsc;
0da71265
MN
220 }
221
222 dst[di++]= src[si++];
223 }
593af7cd
MN
224 while(si<length)
225 dst[di++]= src[si++];
226nsc:
0da71265 227
d4369630
AS
228 memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
229
0da71265
MN
230 *dst_length= di;
231 *consumed= si + 1;//+1 for the header
90b5b51e 232//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
0da71265
MN
233 return dst;
234}
235
1790a5e9 236int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){
0da71265
MN
237 int v= *src;
238 int r;
239
a9c9a240 240 tprintf(h->s.avctx, "rbsp trailing %X\n", v);
0da71265
MN
241
242 for(r=1; r<9; r++){
243 if(v&1) return r;
244 v>>=1;
245 }
246 return 0;
247}
248
249/**
1412060e 250 * IDCT transforms the 16 dc values and dequantizes them.
0da71265
MN
251 * @param qp quantization parameter
252 */
239ea04c 253static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
0da71265
MN
254#define stride 16
255 int i;
256 int temp[16]; //FIXME check if this is a good idea
257 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
258 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
259
260//memset(block, 64, 2*256);
261//return;
262 for(i=0; i<4; i++){
263 const int offset= y_offset[i];
264 const int z0= block[offset+stride*0] + block[offset+stride*4];
265 const int z1= block[offset+stride*0] - block[offset+stride*4];
266 const int z2= block[offset+stride*1] - block[offset+stride*5];
267 const int z3= block[offset+stride*1] + block[offset+stride*5];
268
269 temp[4*i+0]= z0+z3;
270 temp[4*i+1]= z1+z2;
271 temp[4*i+2]= z1-z2;
272 temp[4*i+3]= z0-z3;
273 }
274
275 for(i=0; i<4; i++){
276 const int offset= x_offset[i];
277 const int z0= temp[4*0+i] + temp[4*2+i];
278 const int z1= temp[4*0+i] - temp[4*2+i];
279 const int z2= temp[4*1+i] - temp[4*3+i];
280 const int z3= temp[4*1+i] + temp[4*3+i];
281
1412060e 282 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual
239ea04c
LM
283 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
284 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
285 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
0da71265
MN
286 }
287}
288
e5017ab8 289#if 0
0da71265 290/**
1412060e 291 * DCT transforms the 16 dc values.
0da71265
MN
292 * @param qp quantization parameter ??? FIXME
293 */
294static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
295// const int qmul= dequant_coeff[qp][0];
296 int i;
297 int temp[16]; //FIXME check if this is a good idea
298 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
299 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
300
301 for(i=0; i<4; i++){
302 const int offset= y_offset[i];
303 const int z0= block[offset+stride*0] + block[offset+stride*4];
304 const int z1= block[offset+stride*0] - block[offset+stride*4];
305 const int z2= block[offset+stride*1] - block[offset+stride*5];
306 const int z3= block[offset+stride*1] + block[offset+stride*5];
307
308 temp[4*i+0]= z0+z3;
309 temp[4*i+1]= z1+z2;
310 temp[4*i+2]= z1-z2;
311 temp[4*i+3]= z0-z3;
312 }
313
314 for(i=0; i<4; i++){
315 const int offset= x_offset[i];
316 const int z0= temp[4*0+i] + temp[4*2+i];
317 const int z1= temp[4*0+i] - temp[4*2+i];
318 const int z2= temp[4*1+i] - temp[4*3+i];
319 const int z3= temp[4*1+i] + temp[4*3+i];
320
321 block[stride*0 +offset]= (z0 + z3)>>1;
322 block[stride*2 +offset]= (z1 + z2)>>1;
323 block[stride*8 +offset]= (z1 - z2)>>1;
324 block[stride*10+offset]= (z0 - z3)>>1;
325 }
326}
e5017ab8
LA
327#endif
328
0da71265
MN
329#undef xStride
330#undef stride
331
239ea04c 332static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
0da71265
MN
333 const int stride= 16*2;
334 const int xStride= 16;
335 int a,b,c,d,e;
336
337 a= block[stride*0 + xStride*0];
338 b= block[stride*0 + xStride*1];
339 c= block[stride*1 + xStride*0];
340 d= block[stride*1 + xStride*1];
341
342 e= a-b;
343 a= a+b;
344 b= c-d;
345 c= c+d;
346
239ea04c
LM
347 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
348 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
349 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
350 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
0da71265
MN
351}
352
e5017ab8 353#if 0
0da71265
MN
354static void chroma_dc_dct_c(DCTELEM *block){
355 const int stride= 16*2;
356 const int xStride= 16;
357 int a,b,c,d,e;
358
359 a= block[stride*0 + xStride*0];
360 b= block[stride*0 + xStride*1];
361 c= block[stride*1 + xStride*0];
362 d= block[stride*1 + xStride*1];
363
364 e= a-b;
365 a= a+b;
366 b= c-d;
367 c= c+d;
368
369 block[stride*0 + xStride*0]= (a+c);
370 block[stride*0 + xStride*1]= (e+b);
371 block[stride*1 + xStride*0]= (a-c);
372 block[stride*1 + xStride*1]= (e-b);
373}
e5017ab8 374#endif
0da71265 375
0da71265
MN
376static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
377 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
378 int src_x_offset, int src_y_offset,
379 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
380 MpegEncContext * const s = &h->s;
381 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
5d18eaad 382 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
0da71265 383 const int luma_xy= (mx&3) + ((my&3)<<2);
5d18eaad
LM
384 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
385 uint8_t * src_cb, * src_cr;
386 int extra_width= h->emu_edge_width;
387 int extra_height= h->emu_edge_height;
0da71265
MN
388 int emu=0;
389 const int full_mx= mx>>2;
390 const int full_my= my>>2;
fbd312fd 391 const int pic_width = 16*s->mb_width;
0d43dd8c 392 const int pic_height = 16*s->mb_height >> MB_FIELD;
115329f1 393
0da71265
MN
394 if(mx&7) extra_width -= 3;
395 if(my&7) extra_height -= 3;
115329f1
DB
396
397 if( full_mx < 0-extra_width
398 || full_my < 0-extra_height
399 || full_mx + 16/*FIXME*/ > pic_width + extra_width
fbd312fd 400 || full_my + 16/*FIXME*/ > pic_height + extra_height){
5d18eaad
LM
401 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);
402 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
0da71265
MN
403 emu=1;
404 }
115329f1 405
5d18eaad 406 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
0da71265 407 if(!square){
5d18eaad 408 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
0da71265 409 }
115329f1 410
49fb20cb 411 if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
115329f1 412
0d43dd8c 413 if(MB_FIELD){
5d18eaad 414 // chroma offset when predicting from a field of opposite parity
2143b118 415 my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
5d18eaad
LM
416 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
417 }
418 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
419 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
420
0da71265 421 if(emu){
5d18eaad 422 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);
0da71265
MN
423 src_cb= s->edge_emu_buffer;
424 }
5d18eaad 425 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
0da71265
MN
426
427 if(emu){
5d18eaad 428 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);
0da71265
MN
429 src_cr= s->edge_emu_buffer;
430 }
5d18eaad 431 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
0da71265
MN
432}
433
9f2d1b4f 434static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
0da71265
MN
435 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
436 int x_offset, int y_offset,
437 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
438 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
439 int list0, int list1){
440 MpegEncContext * const s = &h->s;
441 qpel_mc_func *qpix_op= qpix_put;
442 h264_chroma_mc_func chroma_op= chroma_put;
115329f1 443
5d18eaad
LM
444 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
445 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
446 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
0da71265 447 x_offset += 8*s->mb_x;
0d43dd8c 448 y_offset += 8*(s->mb_y >> MB_FIELD);
115329f1 449
0da71265 450 if(list0){
1924f3ce 451 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
0da71265
MN
452 mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
453 dest_y, dest_cb, dest_cr, x_offset, y_offset,
454 qpix_op, chroma_op);
455
456 qpix_op= qpix_avg;
457 chroma_op= chroma_avg;
458 }
459
460 if(list1){
1924f3ce 461 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
0da71265
MN
462 mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
463 dest_y, dest_cb, dest_cr, x_offset, y_offset,
464 qpix_op, chroma_op);
465 }
466}
467
9f2d1b4f
LM
468static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
469 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
470 int x_offset, int y_offset,
471 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
472 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
473 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
474 int list0, int list1){
475 MpegEncContext * const s = &h->s;
476
5d18eaad
LM
477 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
478 dest_cb += x_offset + y_offset*h->mb_uvlinesize;
479 dest_cr += x_offset + y_offset*h->mb_uvlinesize;
9f2d1b4f 480 x_offset += 8*s->mb_x;
0d43dd8c 481 y_offset += 8*(s->mb_y >> MB_FIELD);
115329f1 482
9f2d1b4f
LM
483 if(list0 && list1){
484 /* don't optimize for luma-only case, since B-frames usually
485 * use implicit weights => chroma too. */
486 uint8_t *tmp_cb = s->obmc_scratchpad;
5d18eaad
LM
487 uint8_t *tmp_cr = s->obmc_scratchpad + 8;
488 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize;
9f2d1b4f
LM
489 int refn0 = h->ref_cache[0][ scan8[n] ];
490 int refn1 = h->ref_cache[1][ scan8[n] ];
491
492 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
493 dest_y, dest_cb, dest_cr,
494 x_offset, y_offset, qpix_put, chroma_put);
495 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
496 tmp_y, tmp_cb, tmp_cr,
497 x_offset, y_offset, qpix_put, chroma_put);
498
499 if(h->use_weight == 2){
1052b76f 500 int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1];
9f2d1b4f 501 int weight1 = 64 - weight0;
5d18eaad
LM
502 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0);
503 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
504 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
9f2d1b4f 505 }else{
5d18eaad 506 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
3d9137c8
MN
507 h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0],
508 h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]);
5d18eaad 509 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
3d9137c8
MN
510 h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0],
511 h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]);
5d18eaad 512 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
3d9137c8
MN
513 h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0],
514 h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]);
9f2d1b4f
LM
515 }
516 }else{
517 int list = list1 ? 1 : 0;
518 int refn = h->ref_cache[list][ scan8[n] ];
519 Picture *ref= &h->ref_list[list][refn];
520 mc_dir_part(h, ref, n, square, chroma_height, delta, list,
521 dest_y, dest_cb, dest_cr, x_offset, y_offset,
522 qpix_put, chroma_put);
523
5d18eaad 524 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
3d9137c8 525 h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]);
9f2d1b4f 526 if(h->use_weight_chroma){
5d18eaad 527 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
3d9137c8 528 h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]);
5d18eaad 529 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
3d9137c8 530 h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]);
9f2d1b4f
LM
531 }
532 }
533}
534
535static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
536 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
537 int x_offset, int y_offset,
538 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
539 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
115329f1 540 h264_weight_func *weight_op, h264_biweight_func *weight_avg,
9f2d1b4f
LM
541 int list0, int list1){
542 if((h->use_weight==2 && list0 && list1
1052b76f 543 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32))
9f2d1b4f
LM
544 || h->use_weight==1)
545 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
546 x_offset, y_offset, qpix_put, chroma_put,
547 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
548 else
549 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
550 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
551}
552
513fbd8e
LM
553static inline void prefetch_motion(H264Context *h, int list){
554 /* fetch pixels for estimated mv 4 macroblocks ahead
555 * optimized for 64byte cache lines */
556 MpegEncContext * const s = &h->s;
557 const int refn = h->ref_cache[list][scan8[0]];
558 if(refn >= 0){
559 const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
560 const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
561 uint8_t **src= h->ref_list[list][refn].data;
5d18eaad 562 int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
513fbd8e
LM
563 s->dsp.prefetch(src[0]+off, s->linesize, 4);
564 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
565 s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
566 }
567}
568
0da71265
MN
569static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
570 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
9f2d1b4f
LM
571 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
572 h264_weight_func *weight_op, h264_biweight_func *weight_avg){
0da71265 573 MpegEncContext * const s = &h->s;
64514ee8 574 const int mb_xy= h->mb_xy;
0da71265 575 const int mb_type= s->current_picture.mb_type[mb_xy];
115329f1 576
0da71265 577 assert(IS_INTER(mb_type));
115329f1 578
513fbd8e
LM
579 prefetch_motion(h, 0);
580
0da71265
MN
581 if(IS_16X16(mb_type)){
582 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
583 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
7231ccf4 584 weight_op, weight_avg,
0da71265
MN
585 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
586 }else if(IS_16X8(mb_type)){
587 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
588 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
9f2d1b4f 589 &weight_op[1], &weight_avg[1],
0da71265
MN
590 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
591 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
592 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
9f2d1b4f 593 &weight_op[1], &weight_avg[1],
0da71265
MN
594 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
595 }else if(IS_8X16(mb_type)){
5d18eaad 596 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
0da71265 597 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
9f2d1b4f 598 &weight_op[2], &weight_avg[2],
0da71265 599 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
5d18eaad 600 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
0da71265 601 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
9f2d1b4f 602 &weight_op[2], &weight_avg[2],
0da71265
MN
603 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
604 }else{
605 int i;
115329f1 606
0da71265
MN
607 assert(IS_8X8(mb_type));
608
609 for(i=0; i<4; i++){
610 const int sub_mb_type= h->sub_mb_type[i];
611 const int n= 4*i;
612 int x_offset= (i&1)<<2;
613 int y_offset= (i&2)<<1;
614
615 if(IS_SUB_8X8(sub_mb_type)){
616 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
617 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
9f2d1b4f 618 &weight_op[3], &weight_avg[3],
0da71265
MN
619 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
620 }else if(IS_SUB_8X4(sub_mb_type)){
621 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
622 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
9f2d1b4f 623 &weight_op[4], &weight_avg[4],
0da71265
MN
624 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
625 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
626 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
9f2d1b4f 627 &weight_op[4], &weight_avg[4],
0da71265
MN
628 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
629 }else if(IS_SUB_4X8(sub_mb_type)){
5d18eaad 630 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
0da71265 631 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
9f2d1b4f 632 &weight_op[5], &weight_avg[5],
0da71265 633 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
5d18eaad 634 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
0da71265 635 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
9f2d1b4f 636 &weight_op[5], &weight_avg[5],
0da71265
MN
637 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
638 }else{
639 int j;
640 assert(IS_SUB_4X4(sub_mb_type));
641 for(j=0; j<4; j++){
642 int sub_x_offset= x_offset + 2*(j&1);
643 int sub_y_offset= y_offset + (j&2);
644 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
645 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
9f2d1b4f 646 &weight_op[6], &weight_avg[6],
0da71265
MN
647 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
648 }
649 }
650 }
651 }
513fbd8e
LM
652
653 prefetch_motion(h, 1);
0da71265
MN
654}
655
0da71265 656
0da71265 657static void free_tables(H264Context *h){
7978debd 658 int i;
afebe2f7 659 H264Context *hx;
0da71265 660 av_freep(&h->intra4x4_pred_mode);
e5017ab8
LA
661 av_freep(&h->chroma_pred_mode_table);
662 av_freep(&h->cbp_table);
9e528114
LA
663 av_freep(&h->mvd_table[0]);
664 av_freep(&h->mvd_table[1]);
5ad984c9 665 av_freep(&h->direct_table);
0da71265
MN
666 av_freep(&h->non_zero_count);
667 av_freep(&h->slice_table_base);
668 h->slice_table= NULL;
c988f975 669 av_freep(&h->list_counts);
e5017ab8 670
0da71265 671 av_freep(&h->mb2b_xy);
d43c1922 672 av_freep(&h->mb2br_xy);
9f2d1b4f 673
6752dd5a 674 for(i = 0; i < MAX_THREADS; i++) {
afebe2f7
675 hx = h->thread_context[i];
676 if(!hx) continue;
677 av_freep(&hx->top_borders[1]);
678 av_freep(&hx->top_borders[0]);
679 av_freep(&hx->s.obmc_scratchpad);
d2d5e067
AS
680 av_freep(&hx->rbsp_buffer[1]);
681 av_freep(&hx->rbsp_buffer[0]);
eda4ea4e
MS
682 hx->rbsp_buffer_size[0] = 0;
683 hx->rbsp_buffer_size[1] = 0;
d2d5e067 684 if (i) av_freep(&h->thread_context[i]);
afebe2f7 685 }
0da71265
MN
686}
687
239ea04c
LM
688static void init_dequant8_coeff_table(H264Context *h){
689 int i,q,x;
4693b031 690 const int transpose = (h->h264dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
239ea04c
LM
691 h->dequant8_coeff[0] = h->dequant8_buffer[0];
692 h->dequant8_coeff[1] = h->dequant8_buffer[1];
693
694 for(i=0; i<2; i++ ){
695 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
696 h->dequant8_coeff[1] = h->dequant8_buffer[0];
697 break;
698 }
699
700 for(q=0; q<52; q++){
d9ec210b
DP
701 int shift = div6[q];
702 int idx = rem6[q];
239ea04c 703 for(x=0; x<64; x++)
548a1c8a
LM
704 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
705 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
706 h->pps.scaling_matrix8[i][x]) << shift;
239ea04c
LM
707 }
708 }
709}
710
711static void init_dequant4_coeff_table(H264Context *h){
712 int i,j,q,x;
4693b031 713 const int transpose = (h->h264dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
239ea04c
LM
714 for(i=0; i<6; i++ ){
715 h->dequant4_coeff[i] = h->dequant4_buffer[i];
716 for(j=0; j<i; j++){
717 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
718 h->dequant4_coeff[i] = h->dequant4_buffer[j];
719 break;
720 }
721 }
722 if(j<i)
723 continue;
724
725 for(q=0; q<52; q++){
d9ec210b
DP
726 int shift = div6[q] + 2;
727 int idx = rem6[q];
239ea04c 728 for(x=0; x<16; x++)
ab2e3e2c
LM
729 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
730 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
239ea04c
LM
731 h->pps.scaling_matrix4[i][x]) << shift;
732 }
733 }
734}
735
736static void init_dequant_tables(H264Context *h){
737 int i,x;
738 init_dequant4_coeff_table(h);
739 if(h->pps.transform_8x8_mode)
740 init_dequant8_coeff_table(h);
741 if(h->sps.transform_bypass){
742 for(i=0; i<6; i++)
743 for(x=0; x<16; x++)
744 h->dequant4_coeff[i][0][x] = 1<<6;
745 if(h->pps.transform_8x8_mode)
746 for(i=0; i<2; i++)
747 for(x=0; x<64; x++)
748 h->dequant8_coeff[i][0][x] = 1<<6;
749 }
750}
751
752
903d58f6 753int ff_h264_alloc_tables(H264Context *h){
0da71265 754 MpegEncContext * const s = &h->s;
7bc9090a 755 const int big_mb_num= s->mb_stride * (s->mb_height+1);
145061a1 756 const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;
239ea04c 757 int x,y;
0da71265 758
145061a1 759 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8 * sizeof(uint8_t), fail)
e5017ab8 760
c988f975 761 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count , big_mb_num * 32 * sizeof(uint8_t), fail)
d31dbec3
RP
762 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail)
763 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail)
0da71265 764
d31dbec3 765 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail)
145061a1
MN
766 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail);
767 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail);
36b54927 768 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail);
c988f975 769 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail)
e5017ab8 770
b735aeea 771 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base));
5d18eaad 772 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
0da71265 773
d31dbec3 774 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy , big_mb_num * sizeof(uint32_t), fail);
d43c1922 775 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail);
0da71265
MN
776 for(y=0; y<s->mb_height; y++){
777 for(x=0; x<s->mb_width; x++){
7bc9090a 778 const int mb_xy= x + y*s->mb_stride;
0da71265 779 const int b_xy = 4*x + 4*y*h->b_stride;
115329f1 780
0da71265 781 h->mb2b_xy [mb_xy]= b_xy;
e1c88a21 782 h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride)));
0da71265
MN
783 }
784 }
9f2d1b4f 785
9c6221ae
GV
786 s->obmc_scratchpad = NULL;
787
56edbd81
LM
788 if(!h->dequant4_coeff[0])
789 init_dequant_tables(h);
790
0da71265
MN
791 return 0;
792fail:
793 free_tables(h);
794 return -1;
795}
796
afebe2f7
797/**
798 * Mimic alloc_tables(), but for every context thread.
799 */
145061a1
MN
800static void clone_tables(H264Context *dst, H264Context *src, int i){
801 MpegEncContext * const s = &src->s;
802 dst->intra4x4_pred_mode = src->intra4x4_pred_mode + i*8*2*s->mb_stride;
afebe2f7
803 dst->non_zero_count = src->non_zero_count;
804 dst->slice_table = src->slice_table;
805 dst->cbp_table = src->cbp_table;
806 dst->mb2b_xy = src->mb2b_xy;
d43c1922 807 dst->mb2br_xy = src->mb2br_xy;
afebe2f7 808 dst->chroma_pred_mode_table = src->chroma_pred_mode_table;
145061a1
MN
809 dst->mvd_table[0] = src->mvd_table[0] + i*8*2*s->mb_stride;
810 dst->mvd_table[1] = src->mvd_table[1] + i*8*2*s->mb_stride;
afebe2f7 811 dst->direct_table = src->direct_table;
fb823b77 812 dst->list_counts = src->list_counts;
afebe2f7 813
afebe2f7
814 dst->s.obmc_scratchpad = NULL;
815 ff_h264_pred_init(&dst->hpc, src->s.codec_id);
afebe2f7
816}
817
818/**
819 * Init context
820 * Allocate buffers which are not shared amongst multiple threads.
821 */
822static int context_init(H264Context *h){
d31dbec3
RP
823 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail)
824 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail)
afebe2f7 825
145061a1
MN
826 h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =
827 h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;
828
afebe2f7
829 return 0;
830fail:
831 return -1; // free_tables will clean up for us
832}
833
9855b2e3
MN
834static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size);
835
98a6fff9 836static av_cold void common_init(H264Context *h){
0da71265 837 MpegEncContext * const s = &h->s;
0da71265
MN
838
839 s->width = s->avctx->width;
840 s->height = s->avctx->height;
841 s->codec_id= s->avctx->codec->id;
115329f1 842
4693b031 843 ff_h264dsp_init(&h->h264dsp);
c92a30bb 844 ff_h264_pred_init(&h->hpc, s->codec_id);
0da71265 845
239ea04c 846 h->dequant_coeff_pps= -1;
9a41c2c7 847 s->unrestricted_mv=1;
0da71265 848 s->decode=1; //FIXME
56edbd81 849
a5805aa9
MN
850 dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
851
56edbd81
LM
852 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
853 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
0da71265
MN
854}
855
05e95319
HC
856int ff_h264_decode_extradata(H264Context *h)
857{
858 AVCodecContext *avctx = h->s.avctx;
9855b2e3 859
05e95319 860 if(*(char *)avctx->extradata == 1){
9855b2e3
MN
861 int i, cnt, nalsize;
862 unsigned char *p = avctx->extradata;
863
864 h->is_avc = 1;
865
866 if(avctx->extradata_size < 7) {
867 av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
868 return -1;
869 }
870 /* sps and pps in the avcC always have length coded with 2 bytes,
871 so put a fake nal_length_size = 2 while parsing them */
872 h->nal_length_size = 2;
873 // Decode sps from avcC
874 cnt = *(p+5) & 0x1f; // Number of sps
875 p += 6;
876 for (i = 0; i < cnt; i++) {
877 nalsize = AV_RB16(p) + 2;
878 if(decode_nal_units(h, p, nalsize) < 0) {
879 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
880 return -1;
881 }
882 p += nalsize;
883 }
884 // Decode pps from avcC
885 cnt = *(p++); // Number of pps
886 for (i = 0; i < cnt; i++) {
887 nalsize = AV_RB16(p) + 2;
888 if(decode_nal_units(h, p, nalsize) != nalsize) {
889 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
890 return -1;
891 }
892 p += nalsize;
893 }
894 // Now store right nal length size, that will be use to parse all other nals
895 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
896 } else {
897 h->is_avc = 0;
05e95319 898 if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)
9855b2e3
MN
899 return -1;
900 }
05e95319
HC
901 return 0;
902}
903
904av_cold int ff_h264_decode_init(AVCodecContext *avctx){
905 H264Context *h= avctx->priv_data;
906 MpegEncContext * const s = &h->s;
907
908 MPV_decode_defaults(s);
909
910 s->avctx = avctx;
911 common_init(h);
912
913 s->out_format = FMT_H264;
914 s->workaround_bugs= avctx->workaround_bugs;
915
916 // set defaults
917// s->decode_mb= ff_h263_decode_mb;
918 s->quarter_sample = 1;
919 if(!avctx->has_b_frames)
920 s->low_delay= 1;
921
922 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
923
924 ff_h264_decode_init_vlc();
925
926 h->thread_context[0] = h;
927 h->outputed_poc = INT_MIN;
928 h->prev_poc_msb= 1<<16;
929 h->x264_build = -1;
930 ff_h264_reset_sei(h);
931 if(avctx->codec_id == CODEC_ID_H264){
932 if(avctx->ticks_per_frame == 1){
933 s->avctx->time_base.den *=2;
934 }
935 avctx->ticks_per_frame = 2;
936 }
937
938 if(avctx->extradata_size > 0 && avctx->extradata &&
939 ff_h264_decode_extradata(h))
940 return -1;
941
db8cb47d
MN
942 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){
943 s->avctx->has_b_frames = h->sps.num_reorder_frames;
944 s->low_delay = 0;
945 }
9855b2e3 946
0da71265
MN
947 return 0;
948}
949
903d58f6 950int ff_h264_frame_start(H264Context *h){
0da71265
MN
951 MpegEncContext * const s = &h->s;
952 int i;
953
af8aa846
MN
954 if(MPV_frame_start(s, s->avctx) < 0)
955 return -1;
0da71265 956 ff_er_frame_start(s);
3a22d7fa
JD
957 /*
958 * MPV_frame_start uses pict_type to derive key_frame.
959 * This is incorrect for H.264; IDR markings must be used.
1412060e 960 * Zero here; IDR markings per slice in frame or fields are ORed in later.
3a22d7fa
JD
961 * See decode_nal_units().
962 */
963 s->current_picture_ptr->key_frame= 0;
c173a088 964 s->current_picture_ptr->mmco_reset= 0;
0da71265
MN
965
966 assert(s->linesize && s->uvlinesize);
967
968 for(i=0; i<16; i++){
969 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
6867a90b 970 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
0da71265
MN
971 }
972 for(i=0; i<4; i++){
973 h->block_offset[16+i]=
974 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
6867a90b
LLL
975 h->block_offset[24+16+i]=
976 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
0da71265
MN
977 }
978
934b0821
LM
979 /* can't be in alloc_tables because linesize isn't known there.
980 * FIXME: redo bipred weight to not require extra buffer? */
afebe2f7
981 for(i = 0; i < s->avctx->thread_count; i++)
982 if(!h->thread_context[i]->s.obmc_scratchpad)
983 h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
5d18eaad 984
2ce1c2e0 985 /* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/
5820b90d 986 memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
934b0821 987
0da71265 988// s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
28bb9eb2 989
1412060e 990 // We mark the current picture as non-reference after allocating it, so
28bb9eb2
MN
991 // that if we break out due to an error it can be released automatically
992 // in the next MPV_frame_start().
993 // SVQ3 as well as most other codecs have only last/next/current and thus
994 // get released even with set reference, besides SVQ3 and others do not
995 // mark frames as reference later "naturally".
996 if(s->codec_id != CODEC_ID_SVQ3)
997 s->current_picture_ptr->reference= 0;
357282c6
MN
998
999 s->current_picture_ptr->field_poc[0]=
1000 s->current_picture_ptr->field_poc[1]= INT_MAX;
5118c6c7 1001 assert(s->current_picture_ptr->long_ref==0);
357282c6 1002
af8aa846 1003 return 0;
0da71265
MN
1004}
1005
93cc10fa 1006static 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){
53c05b1e 1007 MpegEncContext * const s = &h->s;
0b69d625 1008 uint8_t *top_border;
5f7f9719 1009 int top_idx = 1;
115329f1 1010
53c05b1e
MN
1011 src_y -= linesize;
1012 src_cb -= uvlinesize;
1013 src_cr -= uvlinesize;
1014
5f7f9719
MN
1015 if(!simple && FRAME_MBAFF){
1016 if(s->mb_y&1){
5f7f9719 1017 if(!MB_MBAFF){
0b69d625
AS
1018 top_border = h->top_borders[0][s->mb_x];
1019 AV_COPY128(top_border, src_y + 15*linesize);
49fb20cb 1020 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
0b69d625
AS
1021 AV_COPY64(top_border+16, src_cb+7*uvlinesize);
1022 AV_COPY64(top_border+24, src_cr+7*uvlinesize);
5f7f9719
MN
1023 }
1024 }
c988f975
MN
1025 }else if(MB_MBAFF){
1026 top_idx = 0;
1027 }else
1028 return;
5f7f9719
MN
1029 }
1030
0b69d625 1031 top_border = h->top_borders[top_idx][s->mb_x];
3b66c4c5 1032 // There are two lines saved, the line above the the top macroblock of a pair,
6867a90b 1033 // and the line above the bottom macroblock
0b69d625 1034 AV_COPY128(top_border, src_y + 16*linesize);
53c05b1e 1035
49fb20cb 1036 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
0b69d625
AS
1037 AV_COPY64(top_border+16, src_cb+8*uvlinesize);
1038 AV_COPY64(top_border+24, src_cr+8*uvlinesize);
53c05b1e
MN
1039 }
1040}
1041
93cc10fa 1042static 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){
53c05b1e 1043 MpegEncContext * const s = &h->s;
b69378e2
1044 int deblock_left;
1045 int deblock_top;
5f7f9719 1046 int top_idx = 1;
1e4f1c56
AS
1047 uint8_t *top_border_m1;
1048 uint8_t *top_border;
5f7f9719
MN
1049
1050 if(!simple && FRAME_MBAFF){
1051 if(s->mb_y&1){
c988f975
MN
1052 if(!MB_MBAFF)
1053 return;
5f7f9719 1054 }else{
5f7f9719
MN
1055 top_idx = MB_MBAFF ? 0 : 1;
1056 }
5f7f9719 1057 }
b69378e2
1058
1059 if(h->deblocking_filter == 2) {
024bf79f
MN
1060 deblock_left = h->left_type[0];
1061 deblock_top = h->top_type;
b69378e2
1062 } else {
1063 deblock_left = (s->mb_x > 0);
6c805007 1064 deblock_top = (s->mb_y > !!MB_FIELD);
b69378e2 1065 }
53c05b1e
MN
1066
1067 src_y -= linesize + 1;
1068 src_cb -= uvlinesize + 1;
1069 src_cr -= uvlinesize + 1;
1070
1e4f1c56
AS
1071 top_border_m1 = h->top_borders[top_idx][s->mb_x-1];
1072 top_border = h->top_borders[top_idx][s->mb_x];
1073
0b69d625
AS
1074#define XCHG(a,b,xchg)\
1075if (xchg) AV_SWAP64(b,a);\
1076else AV_COPY64(b,a);
d89dc06a 1077
d89dc06a 1078 if(deblock_top){
c988f975 1079 if(deblock_left){
0b69d625 1080 XCHG(top_border_m1+8, src_y -7, 1);
c988f975 1081 }
0b69d625
AS
1082 XCHG(top_border+0, src_y +1, xchg);
1083 XCHG(top_border+8, src_y +9, 1);
cad4368a 1084 if(s->mb_x+1 < s->mb_width){
0b69d625 1085 XCHG(h->top_borders[top_idx][s->mb_x+1], src_y +17, 1);
43efd19a 1086 }
53c05b1e 1087 }
53c05b1e 1088
49fb20cb 1089 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
d89dc06a 1090 if(deblock_top){
c988f975 1091 if(deblock_left){
0b69d625
AS
1092 XCHG(top_border_m1+16, src_cb -7, 1);
1093 XCHG(top_border_m1+24, src_cr -7, 1);
c988f975 1094 }
0b69d625
AS
1095 XCHG(top_border+16, src_cb+1, 1);
1096 XCHG(top_border+24, src_cr+1, 1);
53c05b1e 1097 }
53c05b1e
MN
1098 }
1099}
1100
5a6a6cc7 1101static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){
0da71265
MN
1102 MpegEncContext * const s = &h->s;
1103 const int mb_x= s->mb_x;
1104 const int mb_y= s->mb_y;
64514ee8 1105 const int mb_xy= h->mb_xy;
0da71265
MN
1106 const int mb_type= s->current_picture.mb_type[mb_xy];
1107 uint8_t *dest_y, *dest_cb, *dest_cr;
1108 int linesize, uvlinesize /*dct_offset*/;
1109 int i;
6867a90b 1110 int *block_offset = &h->block_offset[0];
41e4055b 1111 const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
8b6871ed 1112 /* is_h264 should always be true if SVQ3 is disabled. */
49fb20cb 1113 const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;
36940eca 1114 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
ef9d1d15 1115 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
0da71265 1116
6120a343
MN
1117 dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
1118 dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
1119 dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
0da71265 1120
a957c27b
LM
1121 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
1122 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);
1123
c988f975
MN
1124 h->list_counts[mb_xy]= h->list_count;
1125
bd91fee3 1126 if (!simple && MB_FIELD) {
5d18eaad
LM
1127 linesize = h->mb_linesize = s->linesize * 2;
1128 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
6867a90b 1129 block_offset = &h->block_offset[24];
1412060e 1130 if(mb_y&1){ //FIXME move out of this function?
0da71265 1131 dest_y -= s->linesize*15;
6867a90b
LLL
1132 dest_cb-= s->uvlinesize*7;
1133 dest_cr-= s->uvlinesize*7;
0da71265 1134 }
5d18eaad
LM
1135 if(FRAME_MBAFF) {
1136 int list;
3425501d 1137 for(list=0; list<h->list_count; list++){
5d18eaad
LM
1138 if(!USES_LIST(mb_type, list))
1139 continue;
1140 if(IS_16X16(mb_type)){
1141 int8_t *ref = &h->ref_cache[list][scan8[0]];
1710856c 1142 fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
5d18eaad
LM
1143 }else{
1144 for(i=0; i<16; i+=4){
5d18eaad
LM
1145 int ref = h->ref_cache[list][scan8[i]];
1146 if(ref >= 0)
1710856c 1147 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
5d18eaad
LM
1148 }
1149 }
1150 }
1151 }
0da71265 1152 } else {
5d18eaad
LM
1153 linesize = h->mb_linesize = s->linesize;
1154 uvlinesize = h->mb_uvlinesize = s->uvlinesize;
0da71265
MN
1155// dct_offset = s->linesize * 16;
1156 }
115329f1 1157
bd91fee3 1158 if (!simple && IS_INTRA_PCM(mb_type)) {
c1708e8d
MN
1159 for (i=0; i<16; i++) {
1160 memcpy(dest_y + i* linesize, h->mb + i*8, 16);
6fbcaaa0 1161 }
c1708e8d
MN
1162 for (i=0; i<8; i++) {
1163 memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4, 8);
1164 memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4, 8);
6fbcaaa0 1165 }
e7e09b49
LLL
1166 } else {
1167 if(IS_INTRA(mb_type)){
5f7f9719 1168 if(h->deblocking_filter)
93cc10fa 1169 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
53c05b1e 1170
49fb20cb 1171 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
c92a30bb
KS
1172 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
1173 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
e7e09b49 1174 }
0da71265 1175
e7e09b49 1176 if(IS_INTRA4x4(mb_type)){
bd91fee3 1177 if(simple || !s->encoding){
43efd19a 1178 if(IS_8x8DCT(mb_type)){
1eb96035
MN
1179 if(transform_bypass){
1180 idct_dc_add =
1181 idct_add = s->dsp.add_pixels8;
dae006d7 1182 }else{
4693b031
MR
1183 idct_dc_add = h->h264dsp.h264_idct8_dc_add;
1184 idct_add = h->h264dsp.h264_idct8_add;
1eb96035 1185 }
43efd19a
LM
1186 for(i=0; i<16; i+=4){
1187 uint8_t * const ptr= dest_y + block_offset[i];
1188 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
41e4055b
MN
1189 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1190 h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);
1191 }else{
ac0623b2
MN
1192 const int nnz = h->non_zero_count_cache[ scan8[i] ];
1193 h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
1194 (h->topright_samples_available<<i)&0x4000, linesize);
1195 if(nnz){
1196 if(nnz == 1 && h->mb[i*16])
1197 idct_dc_add(ptr, h->mb + i*16, linesize);
1198 else
1199 idct_add (ptr, h->mb + i*16, linesize);
1200 }
41e4055b 1201 }
43efd19a 1202 }
1eb96035
MN
1203 }else{
1204 if(transform_bypass){
1205 idct_dc_add =
1206 idct_add = s->dsp.add_pixels4;
1207 }else{
4693b031
MR
1208 idct_dc_add = h->h264dsp.h264_idct_dc_add;
1209 idct_add = h->h264dsp.h264_idct_add;
1eb96035 1210 }
aebb5d6d
MN
1211 for(i=0; i<16; i++){
1212 uint8_t * const ptr= dest_y + block_offset[i];
1213 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
e7e09b49 1214
aebb5d6d
MN
1215 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1216 h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
1217 }else{
1218 uint8_t *topright;
1219 int nnz, tr;
1220 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
1221 const int topright_avail= (h->topright_samples_available<<i)&0x8000;
1222 assert(mb_y || linesize <= block_offset[i]);
1223 if(!topright_avail){
1224 tr= ptr[3 - linesize]*0x01010101;
1225 topright= (uint8_t*) &tr;
1226 }else
1227 topright= ptr + 4 - linesize;
ac0623b2 1228 }else
aebb5d6d
MN
1229 topright= NULL;
1230
1231 h->hpc.pred4x4[ dir ](ptr, topright, linesize);
1232 nnz = h->non_zero_count_cache[ scan8[i] ];
1233 if(nnz){
1234 if(is_h264){
1235 if(nnz == 1 && h->mb[i*16])
1236 idct_dc_add(ptr, h->mb + i*16, linesize);
1237 else
1238 idct_add (ptr, h->mb + i*16, linesize);
1239 }else
881b5b80 1240 ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
aebb5d6d 1241 }
ac0623b2 1242 }
41e4055b 1243 }
8b82a956 1244 }
0da71265 1245 }
e7e09b49 1246 }else{
c92a30bb 1247 h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
bd91fee3 1248 if(is_h264){
36940eca 1249 if(!transform_bypass)
93f0c0a4 1250 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]);
36940eca 1251 }else
881b5b80 1252 ff_svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
0da71265 1253 }
5f7f9719 1254 if(h->deblocking_filter)
93cc10fa 1255 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);
bd91fee3 1256 }else if(is_h264){
e7e09b49 1257 hl_motion(h, dest_y, dest_cb, dest_cr,
2833fc46
LM
1258 s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
1259 s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
4693b031 1260 h->h264dsp.weight_h264_pixels_tab, h->h264dsp.biweight_h264_pixels_tab);
0da71265 1261 }
e7e09b49
LLL
1262
1263
1264 if(!IS_INTRA4x4(mb_type)){
bd91fee3 1265 if(is_h264){
ef9d1d15 1266 if(IS_INTRA16x16(mb_type)){
2fd1f0e0
MN
1267 if(transform_bypass){
1268 if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
0a8ca22f
MN
1269 h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
1270 }else{
1271 for(i=0; i<16; i++){
1272 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
1eb96035 1273 s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize);
0a8ca22f 1274 }
2fd1f0e0
MN
1275 }
1276 }else{
4693b031 1277 h->h264dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
41e4055b 1278 }
49c084a7 1279 }else if(h->cbp&15){
2fd1f0e0 1280 if(transform_bypass){
0a8ca22f 1281 const int di = IS_8x8DCT(mb_type) ? 4 : 1;
1eb96035 1282 idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
0a8ca22f 1283 for(i=0; i<16; i+=di){
62bc966f 1284 if(h->non_zero_count_cache[ scan8[i] ]){
ef9d1d15 1285 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
0a8ca22f 1286 }
ef9d1d15 1287 }
2fd1f0e0
MN
1288 }else{
1289 if(IS_8x8DCT(mb_type)){
4693b031 1290 h->h264dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2fd1f0e0 1291 }else{
4693b031 1292 h->h264dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
2fd1f0e0
MN
1293 }
1294 }
4704097a 1295 }
e7e09b49
LLL
1296 }else{
1297 for(i=0; i<16; i++){
1298 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
6867a90b 1299 uint8_t * const ptr= dest_y + block_offset[i];
881b5b80 1300 ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
e7e09b49 1301 }
4704097a 1302 }
0da71265
MN
1303 }
1304 }
0da71265 1305
49fb20cb 1306 if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
ef9d1d15
LM
1307 uint8_t *dest[2] = {dest_cb, dest_cr};
1308 if(transform_bypass){
96465b90
MN
1309 if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
1310 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize);
1311 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize);
1312 }else{
c25ac15a 1313 idct_add = s->dsp.add_pixels4;
96465b90
MN
1314 for(i=16; i<16+8; i++){
1315 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
1316 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
1317 }
1318 }
ef9d1d15 1319 }else{
4691a77d
1320 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]);
1321 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]);
aebb5d6d 1322 if(is_h264){
1d16a1cf
RB
1323 h->h264dsp.h264_idct_add8(dest, block_offset,
1324 h->mb, uvlinesize,
1325 h->non_zero_count_cache);
aebb5d6d
MN
1326 }else{
1327 for(i=16; i<16+8; i++){
1328 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
1329 uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
881b5b80 1330 ff_svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, ff_h264_chroma_qp[s->qscale + 12] - 12, 2);
aebb5d6d 1331 }
e7e09b49 1332 }
4704097a 1333 }
0da71265
MN
1334 }
1335 }
1336 }
c212fb0c
MN
1337 if(h->cbp || IS_INTRA(mb_type))
1338 s->dsp.clear_blocks(h->mb);
0da71265
MN
1339}
1340
0da71265 1341/**
bd91fee3
AS
1342 * Process a macroblock; this case avoids checks for expensive uncommon cases.
1343 */
1344static void hl_decode_mb_simple(H264Context *h){
1345 hl_decode_mb_internal(h, 1);
1346}
1347
1348/**
1349 * Process a macroblock; this handles edge cases, such as interlacing.
1350 */
1351static void av_noinline hl_decode_mb_complex(H264Context *h){
1352 hl_decode_mb_internal(h, 0);
1353}
1354
903d58f6 1355void ff_h264_hl_decode_mb(H264Context *h){
bd91fee3 1356 MpegEncContext * const s = &h->s;
64514ee8 1357 const int mb_xy= h->mb_xy;
bd91fee3 1358 const int mb_type= s->current_picture.mb_type[mb_xy];
49fb20cb 1359 int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
bd91fee3 1360
bd91fee3
AS
1361 if (is_complex)
1362 hl_decode_mb_complex(h);
1363 else hl_decode_mb_simple(h);
1364}
1365
0da71265
MN
1366static int pred_weight_table(H264Context *h){
1367 MpegEncContext * const s = &h->s;
1368 int list, i;
9f2d1b4f 1369 int luma_def, chroma_def;
115329f1 1370
9f2d1b4f
LM
1371 h->use_weight= 0;
1372 h->use_weight_chroma= 0;
0da71265
MN
1373 h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
1374 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
9f2d1b4f
LM
1375 luma_def = 1<<h->luma_log2_weight_denom;
1376 chroma_def = 1<<h->chroma_log2_weight_denom;
0da71265
MN
1377
1378 for(list=0; list<2; list++){
cb99c652
GB
1379 h->luma_weight_flag[list] = 0;
1380 h->chroma_weight_flag[list] = 0;
0da71265
MN
1381 for(i=0; i<h->ref_count[list]; i++){
1382 int luma_weight_flag, chroma_weight_flag;
115329f1 1383
0da71265
MN
1384 luma_weight_flag= get_bits1(&s->gb);
1385 if(luma_weight_flag){
3d9137c8
MN
1386 h->luma_weight[i][list][0]= get_se_golomb(&s->gb);
1387 h->luma_weight[i][list][1]= get_se_golomb(&s->gb);
1388 if( h->luma_weight[i][list][0] != luma_def
1389 || h->luma_weight[i][list][1] != 0) {
9f2d1b4f 1390 h->use_weight= 1;
cb99c652
GB
1391 h->luma_weight_flag[list]= 1;
1392 }
9f2d1b4f 1393 }else{
3d9137c8
MN
1394 h->luma_weight[i][list][0]= luma_def;
1395 h->luma_weight[i][list][1]= 0;
0da71265
MN
1396 }
1397
0af6967e 1398 if(CHROMA){
fef744d4
MN
1399 chroma_weight_flag= get_bits1(&s->gb);
1400 if(chroma_weight_flag){
1401 int j;
1402 for(j=0; j<2; j++){
3d9137c8
MN
1403 h->chroma_weight[i][list][j][0]= get_se_golomb(&s->gb);
1404 h->chroma_weight[i][list][j][1]= get_se_golomb(&s->gb);
1405 if( h->chroma_weight[i][list][j][0] != chroma_def
1406 || h->chroma_weight[i][list][j][1] != 0) {
fef744d4 1407 h->use_weight_chroma= 1;
cb99c652
GB
1408 h->chroma_weight_flag[list]= 1;
1409 }
fef744d4
MN
1410 }
1411 }else{
1412 int j;
1413 for(j=0; j<2; j++){
3d9137c8
MN
1414 h->chroma_weight[i][list][j][0]= chroma_def;
1415 h->chroma_weight[i][list][j][1]= 0;
fef744d4 1416 }
0da71265
MN
1417 }
1418 }
1419 }
9f5c1037 1420 if(h->slice_type_nos != FF_B_TYPE) break;
0da71265 1421 }
9f2d1b4f 1422 h->use_weight= h->use_weight || h->use_weight_chroma;
0da71265
MN
1423 return 0;
1424}
1425
1052b76f
MN
1426/**
1427 * Initialize implicit_weight table.
6da88bd3 1428 * @param field 0/1 initialize the weight for interlaced MBAFF
1052b76f
MN
1429 * -1 initializes the rest
1430 */
1431static void implicit_weight_table(H264Context *h, int field){
9f2d1b4f 1432 MpegEncContext * const s = &h->s;
1052b76f 1433 int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
9f2d1b4f 1434
ce09f927
GB
1435 for (i = 0; i < 2; i++) {
1436 h->luma_weight_flag[i] = 0;
1437 h->chroma_weight_flag[i] = 0;
1438 }
1439
1052b76f
MN
1440 if(field < 0){
1441 cur_poc = s->current_picture_ptr->poc;
1442 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF
9f2d1b4f
LM
1443 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
1444 h->use_weight= 0;
1445 h->use_weight_chroma= 0;
1446 return;
1447 }
1052b76f
MN
1448 ref_start= 0;
1449 ref_count0= h->ref_count[0];
1450 ref_count1= h->ref_count[1];
1451 }else{
1452 cur_poc = s->current_picture_ptr->field_poc[field];
1453 ref_start= 16;
1454 ref_count0= 16+2*h->ref_count[0];
1455 ref_count1= 16+2*h->ref_count[1];
1456 }
9f2d1b4f
LM
1457
1458 h->use_weight= 2;
1459 h->use_weight_chroma= 2;
1460 h->luma_log2_weight_denom= 5;
1461 h->chroma_log2_weight_denom= 5;
1462
1052b76f 1463 for(ref0=ref_start; ref0 < ref_count0; ref0++){
9f2d1b4f 1464 int poc0 = h->ref_list[0][ref0].poc;
1052b76f 1465 for(ref1=ref_start; ref1 < ref_count1; ref1++){
738386a5 1466 int poc1 = h->ref_list[1][ref1].poc;
f66e4f5f 1467 int td = av_clip(poc1 - poc0, -128, 127);
1052b76f 1468 int w= 32;
9f2d1b4f 1469 if(td){
f66e4f5f 1470 int tb = av_clip(cur_poc - poc0, -128, 127);
c26abfa5 1471 int tx = (16384 + (FFABS(td) >> 1)) / td;
72f86ec0
MN
1472 int dist_scale_factor = (tb*tx + 32) >> 8;
1473 if(dist_scale_factor >= -64 && dist_scale_factor <= 128)
1052b76f
MN
1474 w = 64 - dist_scale_factor;
1475 }
1476 if(field<0){
1477 h->implicit_weight[ref0][ref1][0]=
1478 h->implicit_weight[ref0][ref1][1]= w;
1479 }else{
1480 h->implicit_weight[ref0][ref1][field]=w;
72f86ec0 1481 }
9f2d1b4f
LM
1482 }
1483 }
1484}
1485
8fd57a66 1486/**
5175b937 1487 * instantaneous decoder refresh.
0da71265
MN
1488 */
1489static void idr(H264Context *h){
ea6f00c4 1490 ff_h264_remove_all_refs(h);
a149c1a5 1491 h->prev_frame_num= 0;
80f8e035
MN
1492 h->prev_frame_num_offset= 0;
1493 h->prev_poc_msb=
1494 h->prev_poc_lsb= 0;
0da71265
MN
1495}
1496
7c33ad19
LM
1497/* forget old pics after a seek */
1498static void flush_dpb(AVCodecContext *avctx){
1499 H264Context *h= avctx->priv_data;
1500 int i;
64b9d48f 1501 for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
285b570f
LM
1502 if(h->delayed_pic[i])
1503 h->delayed_pic[i]->reference= 0;
7c33ad19 1504 h->delayed_pic[i]= NULL;
285b570f 1505 }
df8a7dff 1506 h->outputed_poc= INT_MIN;
b19d493f 1507 h->prev_interlaced_frame = 1;
7c33ad19 1508 idr(h);
ca159196
MR
1509 if(h->s.current_picture_ptr)
1510 h->s.current_picture_ptr->reference= 0;
12d96de3 1511 h->s.first_field= 0;
9c095463 1512 ff_h264_reset_sei(h);
e240f898 1513 ff_mpeg_flush(avctx);
7c33ad19
LM
1514}
1515
0da71265
MN
1516static int init_poc(H264Context *h){
1517 MpegEncContext * const s = &h->s;
1518 const int max_frame_num= 1<<h->sps.log2_max_frame_num;
1519 int field_poc[2];
357282c6 1520 Picture *cur = s->current_picture_ptr;
0da71265 1521
b78a6baa 1522 h->frame_num_offset= h->prev_frame_num_offset;
5710b371 1523 if(h->frame_num < h->prev_frame_num)
b78a6baa 1524 h->frame_num_offset += max_frame_num;
0da71265
MN
1525
1526 if(h->sps.poc_type==0){
1527 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
1528
1529 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
1530 h->poc_msb = h->prev_poc_msb + max_poc_lsb;
1531 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
1532 h->poc_msb = h->prev_poc_msb - max_poc_lsb;
1533 else
1534 h->poc_msb = h->prev_poc_msb;
1535//printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
115329f1 1536 field_poc[0] =
0da71265 1537 field_poc[1] = h->poc_msb + h->poc_lsb;
115329f1 1538 if(s->picture_structure == PICT_FRAME)
0da71265
MN
1539 field_poc[1] += h->delta_poc_bottom;
1540 }else if(h->sps.poc_type==1){
1541 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
1542 int i;
1543
1544 if(h->sps.poc_cycle_length != 0)
1545 abs_frame_num = h->frame_num_offset + h->frame_num;
1546 else
1547 abs_frame_num = 0;
1548
1549 if(h->nal_ref_idc==0 && abs_frame_num > 0)
1550 abs_frame_num--;
115329f1 1551
0da71265
MN
1552 expected_delta_per_poc_cycle = 0;
1553 for(i=0; i < h->sps.poc_cycle_length; i++)
1554 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
1555
1556 if(abs_frame_num > 0){
1557 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length;
1558 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
1559
1560 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
1561 for(i = 0; i <= frame_num_in_poc_cycle; i++)
1562 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
1563 } else
1564 expectedpoc = 0;
1565
115329f1 1566 if(h->nal_ref_idc == 0)
0da71265 1567 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
115329f1 1568
0da71265
MN
1569 field_poc[0] = expectedpoc + h->delta_poc[0];
1570 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
1571
1572 if(s->picture_structure == PICT_FRAME)
1573 field_poc[1] += h->delta_poc[1];
1574 }else{
b78a6baa 1575 int poc= 2*(h->frame_num_offset + h->frame_num);
5710b371 1576
b78a6baa
MN
1577 if(!h->nal_ref_idc)
1578 poc--;
5710b371 1579
0da71265
MN
1580 field_poc[0]= poc;
1581 field_poc[1]= poc;
1582 }
115329f1 1583
357282c6 1584 if(s->picture_structure != PICT_BOTTOM_FIELD)
0da71265 1585 s->current_picture_ptr->field_poc[0]= field_poc[0];
357282c6 1586 if(s->picture_structure != PICT_TOP_FIELD)
0da71265 1587 s->current_picture_ptr->field_poc[1]= field_poc[1];
357282c6 1588 cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
0da71265
MN
1589
1590 return 0;
1591}
1592
b41c1db3
1593
1594/**
1595 * initialize scan tables
1596 */
1597static void init_scan_tables(H264Context *h){
b41c1db3 1598 int i;
4693b031 1599 if(h->h264dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
b41c1db3
1600 memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
1601 memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t));
1602 }else{
1603 for(i=0; i<16; i++){
1604#define T(x) (x>>2) | ((x<<2) & 0xF)
1605 h->zigzag_scan[i] = T(zigzag_scan[i]);
1606 h-> field_scan[i] = T( field_scan[i]);
1607#undef T
1608 }
1609 }
4693b031 1610 if(h->h264dsp.h264_idct8_add == ff_h264_idct8_add_c){
45beb850 1611 memcpy(h->zigzag_scan8x8, ff_zigzag_direct, 64*sizeof(uint8_t));
b41c1db3
1612 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));
1613 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t));
1614 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t));
1615 }else{
1616 for(i=0; i<64; i++){
1617#define T(x) (x>>3) | ((x&7)<<3)
45beb850 1618 h->zigzag_scan8x8[i] = T(ff_zigzag_direct[i]);
b41c1db3
1619 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
1620 h->field_scan8x8[i] = T(field_scan8x8[i]);
1621 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]);
1622#undef T
1623 }
1624 }
1625 if(h->sps.transform_bypass){ //FIXME same ugly
1626 h->zigzag_scan_q0 = zigzag_scan;
45beb850 1627 h->zigzag_scan8x8_q0 = ff_zigzag_direct;
b41c1db3
1628 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
1629 h->field_scan_q0 = field_scan;
1630 h->field_scan8x8_q0 = field_scan8x8;
1631 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc;
1632 }else{
1633 h->zigzag_scan_q0 = h->zigzag_scan;
1634 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8;
1635 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
1636 h->field_scan_q0 = h->field_scan;
1637 h->field_scan8x8_q0 = h->field_scan8x8;
1638 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc;
1639 }
1640}
afebe2f7 1641
256299d3
MN
1642static void field_end(H264Context *h){
1643 MpegEncContext * const s = &h->s;
1644 AVCodecContext * const avctx= s->avctx;
1645 s->mb_y= 0;
1646
1647 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
1648 s->current_picture_ptr->pict_type= s->pict_type;
1649
1650 if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1651 ff_vdpau_h264_set_reference_frames(s);
1652
1653 if(!s->dropable) {
ea6f00c4 1654 ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
256299d3
MN
1655 h->prev_poc_msb= h->poc_msb;
1656 h->prev_poc_lsb= h->poc_lsb;
1657 }
1658 h->prev_frame_num_offset= h->frame_num_offset;
1659 h->prev_frame_num= h->frame_num;
1660
1661 if (avctx->hwaccel) {
1662 if (avctx->hwaccel->end_frame(avctx) < 0)
1663 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1664 }
1665
1666 if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1667 ff_vdpau_h264_picture_complete(s);
1668
1669 /*
1670 * FIXME: Error handling code does not seem to support interlaced
1671 * when slices span multiple rows
1672 * The ff_er_add_slice calls don't work right for bottom
1673 * fields; they cause massive erroneous error concealing
1674 * Error marking covers both fields (top and bottom).
1675 * This causes a mismatched s->error_count
1676 * and a bad error table. Further, the error count goes to
1677 * INT_MAX when called for bottom field, because mb_y is
1678 * past end by one (callers fault) and resync_mb_y != 0
1679 * causes problems for the first MB line, too.
1680 */
1681 if (!FIELD_PICTURE)
1682 ff_er_frame_end(s);
1683
1684 MPV_frame_end(s);
d225a1e2
MN
1685
1686 h->current_slice=0;
256299d3
MN
1687}
1688
afebe2f7 1689/**
49bd8e4b 1690 * Replicate H264 "master" context to thread contexts.
afebe2f7
1691 */
1692static void clone_slice(H264Context *dst, H264Context *src)
1693{
1694 memcpy(dst->block_offset, src->block_offset, sizeof(dst->block_offset));
1695 dst->s.current_picture_ptr = src->s.current_picture_ptr;
1696 dst->s.current_picture = src->s.current_picture;
1697 dst->s.linesize = src->s.linesize;
1698 dst->s.uvlinesize = src->s.uvlinesize;
12d96de3 1699 dst->s.first_field = src->s.first_field;
afebe2f7
1700
1701 dst->prev_poc_msb = src->prev_poc_msb;
1702 dst->prev_poc_lsb = src->prev_poc_lsb;
1703 dst->prev_frame_num_offset = src->prev_frame_num_offset;
1704 dst->prev_frame_num = src->prev_frame_num;
1705 dst->short_ref_count = src->short_ref_count;
1706
1707 memcpy(dst->short_ref, src->short_ref, sizeof(dst->short_ref));
1708 memcpy(dst->long_ref, src->long_ref, sizeof(dst->long_ref));
1709 memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));
1710 memcpy(dst->ref_list, src->ref_list, sizeof(dst->ref_list));
50c21814
1711
1712 memcpy(dst->dequant4_coeff, src->dequant4_coeff, sizeof(src->dequant4_coeff));
1713 memcpy(dst->dequant8_coeff, src->dequant8_coeff, sizeof(src->dequant8_coeff));
afebe2f7
1714}
1715
0da71265
MN
1716/**
1717 * decodes a slice header.
9c852bcf 1718 * This will also call MPV_common_init() and frame_start() as needed.
afebe2f7
1719 *
1720 * @param h h264context
1721 * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
1722 *
d9526386 1723 * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
0da71265 1724 */
afebe2f7 1725static int decode_slice_header(H264Context *h, H264Context *h0){
0da71265 1726 MpegEncContext * const s = &h->s;
12d96de3 1727 MpegEncContext * const s0 = &h0->s;
88e7a4d1 1728 unsigned int first_mb_in_slice;
ac658be5 1729 unsigned int pps_id;
0da71265 1730 int num_ref_idx_active_override_flag;
41f5c62f 1731 unsigned int slice_type, tmp, i, j;
0bf79634 1732 int default_ref_list_done = 0;
12d96de3 1733 int last_pic_structure;
0da71265 1734
2f944356 1735 s->dropable= h->nal_ref_idc == 0;
0da71265 1736
cf653d08
JD
1737 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){
1738 s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
1739 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
1740 }else{
1741 s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
1742 s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
1743 }
1744
0da71265
MN
1745 first_mb_in_slice= get_ue_golomb(&s->gb);
1746
d225a1e2
MN
1747 if(first_mb_in_slice == 0){ //FIXME better field boundary detection
1748 if(h0->current_slice && FIELD_PICTURE){
1749 field_end(h);
1750 }
1751
afebe2f7 1752 h0->current_slice = 0;
12d96de3 1753 if (!s0->first_field)
f6e3c460 1754 s->current_picture_ptr= NULL;
66a4b2c1
MN
1755 }
1756
9963b332 1757 slice_type= get_ue_golomb_31(&s->gb);
0bf79634 1758 if(slice_type > 9){
9b879566 1759 av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
5175b937 1760 return -1;
0da71265 1761 }
0bf79634
LLL
1762 if(slice_type > 4){
1763 slice_type -= 5;
0da71265
MN
1764 h->slice_type_fixed=1;
1765 }else
1766 h->slice_type_fixed=0;
115329f1 1767
ee2a957f 1768 slice_type= golomb_to_pict_type[ slice_type ];
9701840b 1769 if (slice_type == FF_I_TYPE
afebe2f7 1770 || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
0bf79634
LLL
1771 default_ref_list_done = 1;
1772 }
1773 h->slice_type= slice_type;
e3e6f18f 1774 h->slice_type_nos= slice_type & 3;
0bf79634 1775
1412060e 1776 s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
115329f1 1777
0da71265 1778 pps_id= get_ue_golomb(&s->gb);
ac658be5 1779 if(pps_id>=MAX_PPS_COUNT){
9b879566 1780 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
0da71265
MN
1781 return -1;
1782 }
afebe2f7 1783 if(!h0->pps_buffers[pps_id]) {
a0f80050 1784 av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id);
8b92b792
MN
1785 return -1;
1786 }
afebe2f7 1787 h->pps= *h0->pps_buffers[pps_id];
8b92b792 1788
afebe2f7 1789 if(!h0->sps_buffers[h->pps.sps_id]) {
a0f80050 1790 av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS %u referenced\n", h->pps.sps_id);
8b92b792
MN
1791 return -1;
1792 }
afebe2f7 1793 h->sps = *h0->sps_buffers[h->pps.sps_id];
239ea04c 1794
fa37cf0d
GB
1795 s->avctx->profile = h->sps.profile_idc;
1796 s->avctx->level = h->sps.level_idc;
6752a3cc 1797 s->avctx->refs = h->sps.ref_frame_count;
b08e38e8 1798
50c21814 1799 if(h == h0 && h->dequant_coeff_pps != pps_id){
50eaa857 1800 h->dequant_coeff_pps = pps_id;
239ea04c
LM
1801 init_dequant_tables(h);
1802 }
115329f1 1803
0da71265 1804 s->mb_width= h->sps.mb_width;
6867a90b 1805 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
115329f1 1806
bf4665ee 1807 h->b_stride= s->mb_width*4;
0da71265 1808
faf3dfb9 1809 s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7);
0da71265 1810 if(h->sps.frame_mbs_only_flag)
faf3dfb9 1811 s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7);
0da71265 1812 else
faf3dfb9 1813 s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 3);
115329f1
DB
1814
1815 if (s->context_initialized
5388f0b4
JK
1816 && ( s->width != s->avctx->width || s->height != s->avctx->height
1817 || av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {
afebe2f7
1818 if(h != h0)
1819 return -1; // width / height changed during parallelized decoding
0da71265 1820 free_tables(h);
ff7f75e1 1821 flush_dpb(s->avctx);
0da71265
MN
1822 MPV_common_end(s);
1823 }
1824 if (!s->context_initialized) {
afebe2f7
1825 if(h != h0)
1826 return -1; // we cant (re-)initialize context during parallel decoding
f3bdc3da
RD
1827
1828 avcodec_set_dimensions(s->avctx, s->width, s->height);
1829 s->avctx->sample_aspect_ratio= h->sps.sar;
cfa5a81e 1830 av_assert0(s->avctx->sample_aspect_ratio.den);
f3bdc3da 1831
c4dffe7e
DC
1832 if(h->sps.video_signal_type_present_flag){
1833 s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
1834 if(h->sps.colour_description_present_flag){
1835 s->avctx->color_primaries = h->sps.color_primaries;
1836 s->avctx->color_trc = h->sps.color_trc;
1837 s->avctx->colorspace = h->sps.colorspace;
1838 }
1839 }
1840
f3bdc3da 1841 if(h->sps.timing_info_present_flag){
3102d180 1842 int64_t den= h->sps.time_scale;
055a6aa7 1843 if(h->x264_build < 44U)
3102d180 1844 den *= 2;
f3bdc3da 1845 av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
3102d180 1846 h->sps.num_units_in_tick, den, 1<<30);
f3bdc3da 1847 }
0435fb16 1848 s->avctx->pix_fmt = s->avctx->get_format(s->avctx,
9ad7dfc1
BC
1849 s->avctx->codec->pix_fmts ?
1850 s->avctx->codec->pix_fmts :
0435fb16
BC
1851 s->avctx->color_range == AVCOL_RANGE_JPEG ?
1852 hwaccel_pixfmt_list_h264_jpeg_420 :
1853 ff_hwaccel_pixfmt_list_420);
f3bdc3da
RD
1854 s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
1855
0da71265
MN
1856 if (MPV_common_init(s) < 0)
1857 return -1;
12d96de3 1858 s->first_field = 0;
b19d493f 1859 h->prev_interlaced_frame = 1;
115329f1 1860
b41c1db3 1861 init_scan_tables(h);
903d58f6 1862 ff_h264_alloc_tables(h);
0da71265 1863
afebe2f7
1864 for(i = 1; i < s->avctx->thread_count; i++) {
1865 H264Context *c;
1866 c = h->thread_context[i] = av_malloc(sizeof(H264Context));
79db7ac6 1867 memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
afebe2f7 1868 memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
7a5c850b 1869 c->h264dsp = h->h264dsp;
afebe2f7
1870 c->sps = h->sps;
1871 c->pps = h->pps;
1872 init_scan_tables(c);
145061a1 1873 clone_tables(c, h, i);
afebe2f7
1874 }
1875
1876 for(i = 0; i < s->avctx->thread_count; i++)
1877 if(context_init(h->thread_context[i]) < 0)
1878 return -1;
0da71265
MN
1879 }
1880
0da71265
MN
1881 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
1882
5d18eaad 1883 h->mb_mbaff = 0;
6ba71fc4 1884 h->mb_aff_frame = 0;
12d96de3 1885 last_pic_structure = s0->picture_structure;
0da71265
MN
1886 if(h->sps.frame_mbs_only_flag){
1887 s->picture_structure= PICT_FRAME;
1888 }else{
6ba71fc4 1889 if(get_bits1(&s->gb)) { //field_pic_flag
0da71265 1890 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
6ba71fc4 1891 } else {
0da71265 1892 s->picture_structure= PICT_FRAME;
6ba71fc4 1893 h->mb_aff_frame = h->sps.mb_aff;
6867a90b 1894 }
0da71265 1895 }
44e9dcf1 1896 h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
2ddcf84b
JD
1897
1898 if(h0->current_slice == 0){
26b86e47
MN
1899 while(h->frame_num != h->prev_frame_num &&
1900 h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
4dece8c7 1901 Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
bb943bb8 1902 av_log(h->s.avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num);
903d58f6 1903 if (ff_h264_frame_start(h) < 0)
66e6038c 1904 return -1;
26b86e47
MN
1905 h->prev_frame_num++;
1906 h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
1907 s->current_picture_ptr->frame_num= h->prev_frame_num;
3d542120
MN
1908 ff_generate_sliding_window_mmcos(h);
1909 ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
e2983d6e
JGG
1910 /* Error concealment: if a ref is missing, copy the previous ref in its place.
1911 * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
1912 * about there being no actual duplicates.
1913 * FIXME: this doesn't copy padding for out-of-frame motion vectors. Given we're
1914 * concealing a lost frame, this probably isn't noticable by comparison, but it should
1915 * be fixed. */
4dece8c7
JGG
1916 if (h->short_ref_count) {
1917 if (prev) {
1918 av_image_copy(h->short_ref[0]->data, h->short_ref[0]->linesize,
1919 (const uint8_t**)prev->data, prev->linesize,
1920 PIX_FMT_YUV420P, s->mb_width*16, s->mb_height*16);
1921 h->short_ref[0]->poc = prev->poc+2;
1922 }
1923 h->short_ref[0]->frame_num = h->prev_frame_num;
1924 }
26b86e47
MN
1925 }
1926
12d96de3
JD
1927 /* See if we have a decoded first field looking for a pair... */
1928 if (s0->first_field) {
1929 assert(s0->current_picture_ptr);
1930 assert(s0->current_picture_ptr->data[0]);
1931 assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);
1932
1933 /* figure out if we have a complementary field pair */
1934 if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {
1935 /*
1936 * Previous field is unmatched. Don't display it, but let it
1937 * remain for reference if marked as such.
1938 */
1939 s0->current_picture_ptr = NULL;
1940 s0->first_field = FIELD_PICTURE;
1941
1942 } else {
1943 if (h->nal_ref_idc &&
1944 s0->current_picture_ptr->reference &&
1945 s0->current_picture_ptr->frame_num != h->frame_num) {
1946 /*
1947 * This and previous field were reference, but had
1948 * different frame_nums. Consider this field first in
1949 * pair. Throw away previous field except for reference
1950 * purposes.
1951 */
1952 s0->first_field = 1;
1953 s0->current_picture_ptr = NULL;
1954
1955 } else {
1956 /* Second field in complementary pair */
1957 s0->first_field = 0;
1958 }
1959 }
1960
1961 } else {
1962 /* Frame or first field in a potentially complementary pair */
1963 assert(!s0->current_picture_ptr);
1964 s0->first_field = FIELD_PICTURE;
1965 }
1966
903d58f6 1967 if((!FIELD_PICTURE || s0->first_field) && ff_h264_frame_start(h) < 0) {
12d96de3 1968 s0->first_field = 0;
2ddcf84b 1969 return -1;
12d96de3 1970 }
2ddcf84b
JD
1971 }
1972 if(h != h0)
1973 clone_slice(h, h0);
1974
1975 s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup
1976
88e7a4d1 1977 assert(s->mb_num == s->mb_width * s->mb_height);
f3e53d9f 1978 if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||
88e7a4d1
MN
1979 first_mb_in_slice >= s->mb_num){
1980 av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
6b53b87e
MN
1981 return -1;
1982 }
88e7a4d1 1983 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
f3e53d9f
JD
1984 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;
1985 if (s->picture_structure == PICT_BOTTOM_FIELD)
1986 s->resync_mb_y = s->mb_y = s->mb_y + 1;
88e7a4d1 1987 assert(s->mb_y < s->mb_height);
115329f1 1988
0da71265
MN
1989 if(s->picture_structure==PICT_FRAME){
1990 h->curr_pic_num= h->frame_num;
1991 h->max_pic_num= 1<< h->sps.log2_max_frame_num;
1992 }else{
f57e2af6 1993 h->curr_pic_num= 2*h->frame_num + 1;
0da71265
MN
1994 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
1995 }
115329f1 1996
0da71265 1997 if(h->nal_unit_type == NAL_IDR_SLICE){
1df1df0b 1998 get_ue_golomb(&s->gb); /* idr_pic_id */
0da71265 1999 }
115329f1 2000
0da71265
MN
2001 if(h->sps.poc_type==0){
2002 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
115329f1 2003
0da71265
MN
2004 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
2005 h->delta_poc_bottom= get_se_golomb(&s->gb);
2006 }
2007 }
115329f1 2008
0da71265
MN
2009 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
2010 h->delta_poc[0]= get_se_golomb(&s->gb);
115329f1 2011
0da71265
MN
2012 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
2013 h->delta_poc[1]= get_se_golomb(&s->gb);
2014 }
115329f1 2015
0da71265 2016 init_poc(h);
115329f1 2017
0da71265
MN
2018 if(h->pps.redundant_pic_cnt_present){
2019 h->redundant_pic_count= get_ue_golomb(&s->gb);
2020 }
2021
1412060e 2022 //set defaults, might be overridden a few lines later
0da71265
MN
2023 h->ref_count[0]= h->pps.ref_count[0];
2024 h->ref_count[1]= h->pps.ref_count[1];
2025
e3e6f18f 2026 if(h->slice_type_nos != FF_I_TYPE){
9f5c1037 2027 if(h->slice_type_nos == FF_B_TYPE){
0da71265
MN
2028 h->direct_spatial_mv_pred= get_bits1(&s->gb);
2029 }
2030 num_ref_idx_active_override_flag= get_bits1(&s->gb);
115329f1 2031
0da71265
MN
2032 if(num_ref_idx_active_override_flag){
2033 h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
9f5c1037 2034 if(h->slice_type_nos==FF_B_TYPE)
0da71265
MN
2035 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
2036
187696fa 2037 if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
9b879566 2038 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
88e7a4d1 2039 h->ref_count[0]= h->ref_count[1]= 1;
0da71265
MN
2040 return -1;
2041 }
2042 }
9f5c1037 2043 if(h->slice_type_nos == FF_B_TYPE)
187696fa
MN
2044 h->list_count= 2;
2045 else
2046 h->list_count= 1;
2047 }else
2048 h->list_count= 0;
0da71265 2049
0bf79634 2050 if(!default_ref_list_done){
ea6f00c4 2051 ff_h264_fill_default_ref_list(h);
0da71265
MN
2052 }
2053
ea6f00c4 2054 if(h->slice_type_nos!=FF_I_TYPE && ff_h264_decode_ref_pic_list_reordering(h) < 0)
806bb93f 2055 return -1;
0da71265 2056
07dff5c7
MN
2057 if(h->slice_type_nos!=FF_I_TYPE){
2058 s->last_picture_ptr= &h->ref_list[0][0];
8d2fc163 2059 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
07dff5c7
MN
2060 }
2061 if(h->slice_type_nos==FF_B_TYPE){
2062 s->next_picture_ptr= &h->ref_list[1][0];
8d2fc163 2063 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
07dff5c7
MN
2064 }
2065
932f396f 2066 if( (h->pps.weighted_pred && h->slice_type_nos == FF_P_TYPE )
9f5c1037 2067 || (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== FF_B_TYPE ) )
0da71265 2068 pred_weight_table(h);
1a29c6a0 2069 else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE){
1052b76f 2070 implicit_weight_table(h, -1);
1a29c6a0 2071 }else {
9f2d1b4f 2072 h->use_weight = 0;
cb99c652
GB
2073 for (i = 0; i < 2; i++) {
2074 h->luma_weight_flag[i] = 0;
2075 h->chroma_weight_flag[i] = 0;
2076 }
2077 }
115329f1 2078
2ddcf84b 2079 if(h->nal_ref_idc)
ea6f00c4 2080 ff_h264_decode_ref_pic_marking(h0, &s->gb);
0da71265 2081
1052b76f 2082 if(FRAME_MBAFF){
ea6f00c4 2083 ff_h264_fill_mbaff_ref_list(h);
5d18eaad 2084
1052b76f
MN
2085 if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE){
2086 implicit_weight_table(h, 0);
2087 implicit_weight_table(h, 1);
2088 }
2089 }
2090
8f56e219 2091 if(h->slice_type_nos==FF_B_TYPE && !h->direct_spatial_mv_pred)
943f69a6
MN
2092 ff_h264_direct_dist_scale_factor(h);
2093 ff_h264_direct_ref_list_init(h);
8f56e219 2094
e3e6f18f 2095 if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){
9963b332 2096 tmp = get_ue_golomb_31(&s->gb);
88e7a4d1
MN
2097 if(tmp > 2){
2098 av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
2099 return -1;
2100 }
2101 h->cabac_init_idc= tmp;
2102 }
e5017ab8
LA
2103
2104 h->last_qscale_diff = 0;
88e7a4d1
MN
2105 tmp = h->pps.init_qp + get_se_golomb(&s->gb);
2106 if(tmp>51){
2107 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
3ebc7e04
MN
2108 return -1;
2109 }
88e7a4d1 2110 s->qscale= tmp;
4691a77d
2111 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2112 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
0da71265 2113 //FIXME qscale / qp ... stuff
9701840b 2114 if(h->slice_type == FF_SP_TYPE){
1df1df0b 2115 get_bits1(&s->gb); /* sp_for_switch_flag */
0da71265 2116 }
9701840b 2117 if(h->slice_type==FF_SP_TYPE || h->slice_type == FF_SI_TYPE){
1df1df0b 2118 get_se_golomb(&s->gb); /* slice_qs_delta */
0da71265
MN
2119 }
2120
53c05b1e 2121 h->deblocking_filter = 1;
0c32e19d
MN
2122 h->slice_alpha_c0_offset = 52;
2123 h->slice_beta_offset = 52;
0da71265 2124 if( h->pps.deblocking_filter_parameters_present ) {
9963b332 2125 tmp= get_ue_golomb_31(&s->gb);
88e7a4d1
MN
2126 if(tmp > 2){
2127 av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
2128 return -1;
2129 }
2130 h->deblocking_filter= tmp;
115329f1 2131 if(h->deblocking_filter < 2)
53c05b1e
MN
2132 h->deblocking_filter^= 1; // 1<->0
2133
2134 if( h->deblocking_filter ) {
0c32e19d
MN
2135 h->slice_alpha_c0_offset += get_se_golomb(&s->gb) << 1;
2136 h->slice_beta_offset += get_se_golomb(&s->gb) << 1;
2137 if( h->slice_alpha_c0_offset > 104U
2138 || h->slice_beta_offset > 104U){
2139 av_log(s->avctx, AV_LOG_ERROR, "deblocking filter parameters %d %d out of range\n", h->slice_alpha_c0_offset, h->slice_beta_offset);
2140 return -1;
2141 }
0da71265 2142 }
980a82b7 2143 }
afebe2f7 2144
61858a76 2145 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL
4b30289e 2146 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != FF_I_TYPE)
9f5c1037 2147 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type_nos == FF_B_TYPE)
61858a76
RD
2148 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
2149 h->deblocking_filter= 0;
2150
afebe2f7 2151 if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
ec970c21
2152 if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
2153 /* Cheat slightly for speed:
5d81d641 2154 Do not bother to deblock across slices. */
ec970c21
2155 h->deblocking_filter = 2;
2156 } else {
7ae94d52
2157 h0->max_contexts = 1;
2158 if(!h0->single_decode_warning) {
2159 av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
2160 h0->single_decode_warning = 1;
2161 }
2162 if(h != h0)
2163 return 1; // deblocking switched inside frame
ec970c21 2164 }
afebe2f7 2165 }
0c32e19d 2166 h->qp_thresh= 15 + 52 - FFMIN(h->slice_alpha_c0_offset, h->slice_beta_offset) - FFMAX3(0, h->pps.chroma_qp_index_offset[0], h->pps.chroma_qp_index_offset[1]);
afebe2f7 2167
0da71265
MN
2168#if 0 //FMO
2169 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
2170 slice_group_change_cycle= get_bits(&s->gb, ?);
2171#endif
2172
afebe2f7
2173 h0->last_slice_type = slice_type;
2174 h->slice_num = ++h0->current_slice;
b735aeea
MN
2175 if(h->slice_num >= MAX_SLICES){
2176 av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
2177 }
5175b937 2178
c32867b5 2179 for(j=0; j<2; j++){
6d7e6b26 2180 int id_list[16];
b735aeea 2181 int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
6d7e6b26
MN
2182 for(i=0; i<16; i++){
2183 id_list[i]= 60;
2184 if(h->ref_list[j][i].data[0]){
2185 int k;
2186 uint8_t *base= h->ref_list[j][i].base[0];
2187 for(k=0; k<h->short_ref_count; k++)
2188 if(h->short_ref[k]->base[0] == base){
2189 id_list[i]= k;
2190 break;
2191 }
2192 for(k=0; k<h->long_ref_count; k++)
2193 if(h->long_ref[k] && h->long_ref[k]->base[0] == base){
2194 id_list[i]= h->short_ref_count + k;
2195 break;
2196 }
2197 }
2198 }
2199
c32867b5
MN
2200 ref2frm[0]=
2201 ref2frm[1]= -1;
d50cdd82 2202 for(i=0; i<16; i++)
6d7e6b26 2203 ref2frm[i+2]= 4*id_list[i]
c32867b5 2204 +(h->ref_list[j][i].reference&3);
d50cdd82
MN
2205 ref2frm[18+0]=
2206 ref2frm[18+1]= -1;
2207 for(i=16; i<48; i++)
6d7e6b26 2208 ref2frm[i+4]= 4*id_list[(i-16)>>1]
d50cdd82 2209 +(h->ref_list[j][i].reference&3);
c32867b5
MN
2210 }
2211
5d18eaad 2212 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
8a11a969 2213 h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
5d18eaad 2214
0da71265 2215 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
49573a87 2216 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
6867a90b
LLL
2217 h->slice_num,
2218 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
115329f1 2219 first_mb_in_slice,
49573a87 2220 av_get_pict_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
0da71265
MN
2221 pps_id, h->frame_num,
2222 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
2223 h->ref_count[0], h->ref_count[1],
2224 s->qscale,
0c32e19d 2225 h->deblocking_filter, h->slice_alpha_c0_offset/2-26, h->slice_beta_offset/2-26,
9f2d1b4f 2226 h->use_weight,
4806b922
MN
2227 h->use_weight==1 && h->use_weight_chroma ? "c" : "",
2228 h->slice_type == FF_B_TYPE ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""
0da71265
MN
2229 );
2230 }
2231
2232 return 0;
2233}
2234
0dc343d4 2235int ff_h264_get_slice_type(const H264Context *h)
75dd6938
LA
2236{
2237 switch (h->slice_type) {
2238 case FF_P_TYPE: return 0;
2239 case FF_B_TYPE: return 1;
2240 case FF_I_TYPE: return 2;
2241 case FF_SP_TYPE: return 3;
2242 case FF_SI_TYPE: return 4;
2243 default: return -1;
2244 }
2245}
2246
d02bb3ec
DB
2247/**
2248 *
2249 * @return non zero if the loop filter can be skiped
2250 */
2251static int fill_filter_caches(H264Context *h, int mb_type){
2252 MpegEncContext * const s = &h->s;
2253 const int mb_xy= h->mb_xy;
2254 int top_xy, left_xy[2];
2255 int top_type, left_type[2];
2256
2257 top_xy = mb_xy - (s->mb_stride << MB_FIELD);
2258
2259 //FIXME deblocking could skip the intra and nnz parts.
2260
2261 /* Wow, what a mess, why didn't they simplify the interlacing & intra
2262 * stuff, I can't imagine that these complex rules are worth it. */
2263
2264 left_xy[1] = left_xy[0] = mb_xy-1;
2265 if(FRAME_MBAFF){
2266 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
2267 const int curr_mb_field_flag = IS_INTERLACED(mb_type);
2268 if(s->mb_y&1){
2269 if (left_mb_field_flag != curr_mb_field_flag) {
2270 left_xy[0] -= s->mb_stride;
2271 }
2272 }else{
2273 if(curr_mb_field_flag){
2274 top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1);
2275 }
2276 if (left_mb_field_flag != curr_mb_field_flag) {
2277 left_xy[1] += s->mb_stride;
2278 }
2279 }
2280 }
2281
2282 h->top_mb_xy = top_xy;
2283 h->left_mb_xy[0] = left_xy[0];
2284 h->left_mb_xy[1] = left_xy[1];
2285 {
2286 //for sufficiently low qp, filtering wouldn't do anything
2287 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
2288 int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
2289 int qp = s->current_picture.qscale_table[mb_xy];
2290 if(qp <= qp_thresh
2291 && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
2292 && (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){
2293 if(!FRAME_MBAFF)
2294 return 1;
2295 if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh)
2296 && (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh))
2297 return 1;
2298 }
2299 }
2300
2301 top_type = s->current_picture.mb_type[top_xy] ;
2302 left_type[0] = s->current_picture.mb_type[left_xy[0]];
2303 left_type[1] = s->current_picture.mb_type[left_xy[1]];
2304 if(h->deblocking_filter == 2){
2305 if(h->slice_table[top_xy ] != h->slice_num) top_type= 0;
2306 if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;
2307 }else{
2308 if(h->slice_table[top_xy ] == 0xFFFF) top_type= 0;
2309 if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;
2310 }
2311 h->top_type = top_type ;
2312 h->left_type[0]= left_type[0];
2313 h->left_type[1]= left_type[1];
2314
2315 if(IS_INTRA(mb_type))
2316 return 0;
2317
2318 AV_COPY64(&h->non_zero_count_cache[0+8*1], &h->non_zero_count[mb_xy][ 0]);
2319 AV_COPY64(&h->non_zero_count_cache[0+8*2], &h->non_zero_count[mb_xy][ 8]);
2320 AV_COPY32(&h->non_zero_count_cache[0+8*5], &h->non_zero_count[mb_xy][16]);
2321 AV_COPY32(&h->non_zero_count_cache[4+8*3], &h->non_zero_count[mb_xy][20]);
2322 AV_COPY64(&h->non_zero_count_cache[0+8*4], &h->non_zero_count[mb_xy][24]);
2323
2324 h->cbp= h->cbp_table[mb_xy];
2325
2326 {
2327 int list;
2328 for(list=0; list<h->list_count; list++){
2329 int8_t *ref;
2330 int y, b_stride;
2331 int16_t (*mv_dst)[2];
2332 int16_t (*mv_src)[2];
2333
2334 if(!USES_LIST(mb_type, list)){
2335 fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
2336 AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2337 AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2338 AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2339 AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2340 continue;
2341 }
2342
2343 ref = &s->current_picture.ref_index[list][4*mb_xy];
2344 {
2345 int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2346 AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2347 AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2348 ref += 2;
2349 AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2350 AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2351 }
2352
2353 b_stride = h->b_stride;
2354 mv_dst = &h->mv_cache[list][scan8[0]];
2355 mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
2356 for(y=0; y<4; y++){
2357 AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
2358 }
2359
2360 }
2361 }
2362
2363
2364/*
23650 . T T. T T T T
23661 L . .L . . . .
23672 L . .L . . . .
23683 . T TL . . . .
23694 L . .L . . . .
23705 L . .. . . . .
2371*/
2372//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
2373 if(top_type){
2374 AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]);
2375 }
2376
2377 if(left_type[0]){
2378 h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][7+0*8];
2379 h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][7+1*8];
2380 h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][7+2*8];
2381 h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][7+3*8];
2382 }
2383
2384 // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
2385 if(!CABAC && h->pps.transform_8x8_mode){
2386 if(IS_8x8DCT(top_type)){
2387 h->non_zero_count_cache[4+8*0]=
2388 h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4;
2389 h->non_zero_count_cache[6+8*0]=
2390 h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8;
2391 }
2392 if(IS_8x8DCT(left_type[0])){
2393 h->non_zero_count_cache[3+8*1]=
2394 h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF
2395 }
2396 if(IS_8x8DCT(left_type[1])){
2397 h->non_zero_count_cache[3+8*3]=
2398 h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF
2399 }
2400
2401 if(IS_8x8DCT(mb_type)){
2402 h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=
2403 h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp & 1;
2404
2405 h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
2406 h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
2407
2408 h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
2409 h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
2410
2411 h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
2412 h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
2413 }
2414 }
2415
2416 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
2417 int list;
2418 for(list=0; list<h->list_count; list++){
2419 if(USES_LIST(top_type, list)){
2420 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
2421 const int b8_xy= 4*top_xy + 2;
2422 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2423 AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
2424 h->ref_cache[list][scan8[0] + 0 - 1*8]=
2425 h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
2426 h->ref_cache[list][scan8[0] + 2 - 1*8]=
2427 h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
2428 }else{
2429 AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
2430 AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2431 }
2432
2433 if(!IS_INTERLACED(mb_type^left_type[0])){
2434 if(USES_LIST(left_type[0], list)){
2435 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
2436 const int b8_xy= 4*left_xy[0] + 1;
2437 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2438 AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);
2439 AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);
2440 AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);
2441 AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);
2442 h->ref_cache[list][scan8[0] - 1 + 0 ]=
2443 h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];
2444 h->ref_cache[list][scan8[0] - 1 +16 ]=
2445 h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];
2446 }else{
2447 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);
2448 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);
2449 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);
2450 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);
2451 h->ref_cache[list][scan8[0] - 1 + 0 ]=
2452 h->ref_cache[list][scan8[0] - 1 + 8 ]=
2453 h->ref_cache[list][scan8[0] - 1 + 16 ]=
2454 h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
2455 }
2456 }
2457 }
2458 }
2459
2460 return 0;
2461}
2462
c988f975
MN
2463static void loop_filter(H264Context *h){
2464 MpegEncContext * const s = &h->s;
2465 uint8_t *dest_y, *dest_cb, *dest_cr;
2466 int linesize, uvlinesize, mb_x, mb_y;
2467 const int end_mb_y= s->mb_y + FRAME_MBAFF;
2468 const int old_slice_type= h->slice_type;
2469
2470 if(h->deblocking_filter) {
2471 for(mb_x= 0; mb_x<s->mb_width; mb_x++){
2472 for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){
78998bf2 2473 int mb_xy, mb_type;
c988f975
MN
2474 mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;
2475 h->slice_num= h->slice_table[mb_xy];
2476 mb_type= s->current_picture.mb_type[mb_xy];
2477 h->list_count= h->list_counts[mb_xy];
c988f975
MN
2478
2479 if(FRAME_MBAFF)
2480 h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2481
c988f975
MN
2482 s->mb_x= mb_x;
2483 s->mb_y= mb_y;
2484 dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
2485 dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
2486 dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
2487 //FIXME simplify above
2488
2489 if (MB_FIELD) {
2490 linesize = h->mb_linesize = s->linesize * 2;
2491 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
2492 if(mb_y&1){ //FIXME move out of this function?
2493 dest_y -= s->linesize*15;
2494 dest_cb-= s->uvlinesize*7;
2495 dest_cr-= s->uvlinesize*7;
2496 }
2497 } else {
2498 linesize = h->mb_linesize = s->linesize;
2499 uvlinesize = h->mb_uvlinesize = s->uvlinesize;
2500 }
77d40dce 2501 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
aaa995d7 2502 if(fill_filter_caches(h, mb_type))
44a5e7b6 2503 continue;
c988f975
MN
2504 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
2505 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
2506
77d40dce 2507 if (FRAME_MBAFF) {
c988f975
MN
2508 ff_h264_filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2509 } else {
2510 ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2511 }
2512 }
2513 }
2514 }
2515 h->slice_type= old_slice_type;
2516 s->mb_x= 0;
2517 s->mb_y= end_mb_y - FRAME_MBAFF;
f4b8b825
MN
2518 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2519 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
c988f975
MN
2520}
2521
69a28f3e
MN
2522static void predict_field_decoding_flag(H264Context *h){
2523 MpegEncContext * const s = &h->s;
2524 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
2525 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
2526 ? s->current_picture.mb_type[mb_xy-1]
2527 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
2528 ? s->current_picture.mb_type[mb_xy-s->mb_stride]
2529 : 0;
2530 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2531}
2532
3a84713a
RS
2533static int decode_slice(struct AVCodecContext *avctx, void *arg){
2534 H264Context *h = *(void**)arg;
0da71265
MN
2535 MpegEncContext * const s = &h->s;
2536 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
2537
2538 s->mb_skip_run= -1;
0da71265 2539
89db0bae 2540 h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
5317c95b 2541 (CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY));
89db0bae 2542
e5017ab8 2543 if( h->pps.cabac ) {
e5017ab8
LA
2544 /* realign */
2545 align_get_bits( &s->gb );
2546
2547 /* init cabac */
d61c4e73 2548 ff_init_cabac_states( &h->cabac);
e5017ab8
LA
2549 ff_init_cabac_decoder( &h->cabac,
2550 s->gb.buffer + get_bits_count(&s->gb)/8,
6e44ba15 2551 (get_bits_left(&s->gb) + 7)/8);
cc51b282
MN
2552
2553 ff_h264_init_cabac_states(h);
95c26348 2554
e5017ab8 2555 for(;;){
851ded89 2556//START_TIMER
cc51b282 2557 int ret = ff_h264_decode_mb_cabac(h);
6867a90b 2558 int eos;
851ded89 2559//STOP_TIMER("decode_mb_cabac")
0da71265 2560
903d58f6 2561 if(ret>=0) ff_h264_hl_decode_mb(h);
0da71265 2562
5d18eaad 2563 if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
e5017ab8
LA
2564 s->mb_y++;
2565
cc51b282 2566 ret = ff_h264_decode_mb_cabac(h);
e5017ab8 2567
903d58f6 2568 if(ret>=0) ff_h264_hl_decode_mb(h);
e5017ab8
LA
2569 s->mb_y--;
2570 }
6867a90b 2571 eos = get_cabac_terminate( &h->cabac );
e5017ab8 2572
3566042a
MN
2573 if((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2){
2574 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2575 return 0;
2576 }
5659b509 2577 if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
706da4af 2578 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream);
e5017ab8
LA
2579 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
2580 return -1;
2581 }
2582
2583 if( ++s->mb_x >= s->mb_width ) {
2584 s->mb_x = 0;
c988f975 2585 loop_filter(h);
e5017ab8 2586 ff_draw_horiz_band(s, 16*s->mb_y, 16);
5175b937 2587 ++s->mb_y;
f3e53d9f 2588 if(FIELD_OR_MBAFF_PICTURE) {
6867a90b 2589 ++s->mb_y;
69cc3183
MN
2590 if(FRAME_MBAFF && s->mb_y < s->mb_height)
2591 predict_field_decoding_flag(h);
6867a90b 2592 }
0da71265 2593 }
0da71265 2594
e5017ab8 2595 if( eos || s->mb_y >= s->mb_height ) {
a9c9a240 2596 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
e5017ab8 2597 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
0da71265 2598 return 0;
e5017ab8 2599 }
e5017ab8
LA
2600 }
2601
2602 } else {
2603 for(;;){
e1e94902 2604 int ret = ff_h264_decode_mb_cavlc(h);
e5017ab8 2605
903d58f6 2606 if(ret>=0) ff_h264_hl_decode_mb(h);
e5017ab8 2607
5d18eaad 2608 if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
e5017ab8 2609 s->mb_y++;
e1e94902 2610 ret = ff_h264_decode_mb_cavlc(h);
e5017ab8 2611
903d58f6 2612 if(ret>=0) ff_h264_hl_decode_mb(h);
e5017ab8
LA
2613 s->mb_y--;
2614 }
2615
2616 if(ret<0){
2617 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
0da71265
MN
2618 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
2619
2620 return -1;
2621 }
e5017ab8
LA
2622
2623 if(++s->mb_x >= s->mb_width){
2624 s->mb_x=0;
c988f975 2625 loop_filter(h);
e5017ab8 2626 ff_draw_horiz_band(s, 16*s->mb_y, 16);
6867a90b 2627 ++s->mb_y;
f3e53d9f 2628 if(FIELD_OR_MBAFF_PICTURE) {
6867a90b 2629 ++s->mb_y;
69cc3183
MN
2630 if(FRAME_MBAFF && s->mb_y < s->mb_height)
2631 predict_field_decoding_flag(h);
6867a90b
LLL
2632 }
2633 if(s->mb_y >= s->mb_height){
a9c9a240 2634 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
e5017ab8
LA
2635
2636 if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
2637 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2638
2639 return 0;
2640 }else{
2641 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2642
2643 return -1;
2644 }
2645 }
2646 }
2647
2648 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
a9c9a240 2649 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
e5017ab8
LA
2650 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
2651 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2652
2653 return 0;
2654 }else{
2655 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
2656
2657 return -1;
2658 }
2659 }
0da71265
MN
2660 }
2661 }
e5017ab8 2662
0da71265
MN
2663#if 0
2664 for(;s->mb_y < s->mb_height; s->mb_y++){
2665 for(;s->mb_x < s->mb_width; s->mb_x++){
2666 int ret= decode_mb(h);
115329f1 2667
903d58f6 2668 ff_h264_hl_decode_mb(h);
0da71265
MN
2669
2670 if(ret<0){
267f7edc 2671 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
0da71265
MN
2672 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
2673
2674 return -1;
2675 }
115329f1 2676
0da71265
MN
2677 if(++s->mb_x >= s->mb_width){
2678 s->mb_x=0;
2679 if(++s->mb_y >= s->mb_height){
2680 if(get_bits_count(s->gb) == s->gb.size_in_bits){
2681 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2682
2683 return 0;
2684 }else{
2685 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2686
2687 return -1;
2688 }
2689 }
2690 }
115329f1 2691
0da71265
MN
2692 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
2693 if(get_bits_count(s->gb) == s->gb.size_in_bits){
2694 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
2695
2696 return 0;
2697 }else{
2698 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
2699
2700 return -1;
2701 }
2702 }
2703 }
2704 s->mb_x=0;
2705 ff_draw_horiz_band(s, 16*s->mb_y, 16);
2706 }
2707#endif
2708 return -1; //not reached
2709}
2710
afebe2f7
2711/**
2712 * Call decode_slice() for each context.
2713 *
2714 * @param h h264 master context
2715 * @param context_count number of contexts to execute
2716 */
2717static void execute_decode_slices(H264Context *h, int context_count){
2718 MpegEncContext * const s = &h->s;
2719 AVCodecContext * const avctx= s->avctx;
2720 H264Context *hx;
2721 int i;
2722
40e5d31b
GB
2723 if (s->avctx->hwaccel)
2724 return;
0d3d172f 2725 if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
369122dd 2726 return;
afebe2f7 2727 if(context_count == 1) {
74e8b78b 2728 decode_slice(avctx, &h);
afebe2f7
2729 } else {
2730 for(i = 1; i < context_count; i++) {
2731 hx = h->thread_context[i];
047599a4 2732 hx->s.error_recognition = avctx->error_recognition;
afebe2f7
2733 hx->s.error_count = 0;
2734 }
2735
2736 avctx->execute(avctx, (void *)decode_slice,
01418506 2737 h->thread_context, NULL, context_count, sizeof(void*));
afebe2f7
2738
2739 /* pull back stuff from slices to master context */
2740 hx = h->thread_context[context_count - 1];
2741 s->mb_x = hx->s.mb_x;
2742 s->mb_y = hx->s.mb_y;
12d96de3
JD
2743 s->dropable = hx->s.dropable;
2744 s->picture_structure = hx->s.picture_structure;
afebe2f7
2745 for(i = 1; i < context_count; i++)
2746 h->s.error_count += h->thread_context[i]->s.error_count;
2747 }
2748}
2749
2750
30317501 2751static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
0da71265
MN
2752 MpegEncContext * const s = &h->s;
2753 AVCodecContext * const avctx= s->avctx;
2754 int buf_index=0;
afebe2f7
2755 H264Context *hx; ///< thread context
2756 int context_count = 0;
74b14aac 2757 int next_avc= h->is_avc ? 0 : buf_size;
afebe2f7
2758
2759 h->max_contexts = avctx->thread_count;
377ec888 2760#if 0
eb60dddc 2761 int i;
96b6ace2
MN
2762 for(i=0; i<50; i++){
2763 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
0da71265
MN
2764 }
2765#endif
66a4b2c1 2766 if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
afebe2f7 2767 h->current_slice = 0;
12d96de3 2768 if (!s->first_field)
f6e3c460 2769 s->current_picture_ptr= NULL;
9c095463 2770 ff_h264_reset_sei(h);
66a4b2c1
MN
2771 }
2772
0da71265
MN
2773 for(;;){
2774 int consumed;
2775 int dst_length;
2776 int bit_length;
30317501 2777 const uint8_t *ptr;
4770b1b4 2778 int i, nalsize = 0;
afebe2f7 2779 int err;
115329f1 2780
74b14aac 2781 if(buf_index >= next_avc) {
1c48415b
2782 if(buf_index >= buf_size) break;
2783 nalsize = 0;
2784 for(i = 0; i < h->nal_length_size; i++)
2785 nalsize = (nalsize << 8) | buf[buf_index++];
8d8409ca 2786 if(nalsize <= 1 || nalsize > buf_size - buf_index){
1c48415b
2787 if(nalsize == 1){
2788 buf_index++;
2789 continue;
2790 }else{
2791 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
2792 break;
2793 }
2794 }
74b14aac 2795 next_avc= buf_index + nalsize;
1c48415b
2796 } else {
2797 // start code prefix search
52255d17 2798 for(; buf_index + 3 < next_avc; buf_index++){
1c48415b
2799 // This should always succeed in the first iteration.
2800 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
2801 break;
8b031359 2802 }
115329f1 2803
1c48415b 2804 if(buf_index+3 >= buf_size) break;
115329f1 2805
1c48415b 2806 buf_index+=3;
52255d17 2807 if(buf_index >= next_avc) continue;
1c48415b 2808 }
115329f1 2809
afebe2f7
2810 hx = h->thread_context[context_count];
2811
74b14aac 2812 ptr= ff_h264_decode_nal(hx, buf + buf_index, &dst_length, &consumed, next_avc - buf_index);
ff82e429 2813 if (ptr==NULL || dst_length < 0){
ac658be5
FOL
2814 return -1;
2815 }
3566042a
MN
2816 i= buf_index + consumed;
2817 if((s->workaround_bugs & FF_BUG_AUTODETECT) && i+3<next_avc &&
2818 buf[i]==0x00 && buf[i+1]==0x00 && buf[i+2]==0x01 && buf[i+3]==0xE0)
2819 s->workaround_bugs |= FF_BUG_TRUNCATED;
2820
2821 if(!(s->workaround_bugs & FF_BUG_TRUNCATED)){
6ac9696e 2822 while(ptr[dst_length - 1] == 0 && dst_length > 0)
c4da83fb 2823 dst_length--;
3566042a 2824 }
1790a5e9 2825 bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));
0da71265
MN
2826
2827 if(s->avctx->debug&FF_DEBUG_STARTCODE){
afebe2f7 2828 av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length);
0da71265 2829 }
115329f1 2830
74b14aac 2831 if (h->is_avc && (nalsize != consumed) && nalsize){
e262365d 2832 av_log(h->s.avctx, AV_LOG_DEBUG, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
9d2cc8c1 2833 }
4770b1b4 2834
0da71265
MN
2835 buf_index += consumed;
2836
755bfeab 2837 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME do not discard SEI id
8c3eba7c 2838 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
0da71265 2839 continue;
115329f1 2840
afebe2f7
2841 again:
2842 err = 0;
2843 switch(hx->nal_unit_type){
0da71265 2844 case NAL_IDR_SLICE:
afebe2f7
2845 if (h->nal_unit_type != NAL_IDR_SLICE) {
2846 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices");
2847 return -1;
2848 }
3b66c4c5 2849 idr(h); //FIXME ensure we don't loose some frames if there is reordering
0da71265 2850 case NAL_SLICE:
afebe2f7
2851 init_get_bits(&hx->s.gb, ptr, bit_length);
2852 hx->intra_gb_ptr=
2853 hx->inter_gb_ptr= &hx->s.gb;
2854 hx->s.data_partitioning = 0;
2855
2856 if((err = decode_slice_header(hx, h)))
2857 break;
2858
3bccd93a
SW
2859 if (h->current_slice == 1) {
2860 if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)
6026a096 2861 return -1;
3bccd93a
SW
2862 if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2863 ff_vdpau_h264_picture_start(s);
6026a096
GB
2864 }
2865
37a558fe
IS
2866 s->current_picture_ptr->key_frame |=
2867 (hx->nal_unit_type == NAL_IDR_SLICE) ||
2868 (h->sei_recovery_frame_cnt >= 0);
afebe2f7
2869 if(hx->redundant_pic_count==0 && hx->s.hurry_up < 5
2870 && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
9f5c1037 2871 && (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=FF_B_TYPE)
4b30289e 2872 && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
369122dd 2873 && avctx->skip_frame < AVDISCARD_ALL){
d404b3ed
MN
2874 if(avctx->hwaccel) {
2875 if (avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], consumed) < 0)
2876 return -1;
2877 }else
0d3d172f 2878 if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
369122dd 2879 static const uint8_t start_code[] = {0x00, 0x00, 0x01};
c639fc72
CEH
2880 ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code));
2881 ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed );
369122dd 2882 }else
f2c214a1 2883 context_count++;
369122dd 2884 }
0da71265
MN
2885 break;
2886 case NAL_DPA:
afebe2f7
2887 init_get_bits(&hx->s.gb, ptr, bit_length);
2888 hx->intra_gb_ptr=
2889 hx->inter_gb_ptr= NULL;
0410ee8f
AS
2890
2891 if ((err = decode_slice_header(hx, h)) < 0)
2892 break;
2893
afebe2f7 2894 hx->s.data_partitioning = 1;
115329f1 2895
0da71265
MN
2896 break;
2897 case NAL_DPB:
afebe2f7
2898 init_get_bits(&hx->intra_gb, ptr, bit_length);
2899 hx->intra_gb_ptr= &hx->intra_gb;
0da71265
MN
2900 break;
2901 case NAL_DPC:
afebe2f7
2902 init_get_bits(&hx->inter_gb, ptr, bit_length);
2903 hx->inter_gb_ptr= &hx->inter_gb;
8b92b792 2904
afebe2f7 2905 if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning
b18e5c03 2906 && s->context_initialized
e0111b32 2907 && s->hurry_up < 5
afebe2f7 2908 && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
9f5c1037 2909 && (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=FF_B_TYPE)
4b30289e 2910 && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
e0111b32 2911 && avctx->skip_frame < AVDISCARD_ALL)
afebe2f7 2912 context_count++;
0da71265
MN
2913 break;
2914 case NAL_SEI:
cdd10689 2915 init_get_bits(&s->gb, ptr, bit_length);
1790a5e9 2916 ff_h264_decode_sei(h);
0da71265
MN
2917 break;
2918 case NAL_SPS:
2919 init_get_bits(&s->gb, ptr, bit_length);
1790a5e9 2920 ff_h264_decode_seq_parameter_set(h);
115329f1 2921
0da71265
MN
2922 if(s->flags& CODEC_FLAG_LOW_DELAY)
2923 s->low_delay=1;
115329f1 2924
a18030bb
LM
2925 if(avctx->has_b_frames < 2)
2926 avctx->has_b_frames= !s->low_delay;
0da71265
MN
2927 break;
2928 case NAL_PPS:
2929 init_get_bits(&s->gb, ptr, bit_length);
115329f1 2930
1790a5e9 2931 ff_h264_decode_picture_parameter_set(h, bit_length);
0da71265
MN
2932
2933 break;
ab470fa7
LM
2934 case NAL_AUD:
2935 case NAL_END_SEQUENCE:
2936 case NAL_END_STREAM:
2937 case NAL_FILLER_DATA:
2938 case NAL_SPS_EXT:
2939 case NAL_AUXILIARY_SLICE:
0da71265 2940 break;
bb270c08 2941 default:
4ad04da2 2942 av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", hx->nal_unit_type, bit_length);
115329f1 2943 }
115329f1 2944
afebe2f7
2945 if(context_count == h->max_contexts) {
2946 execute_decode_slices(h, context_count);
2947 context_count = 0;
2948 }
2949
2950 if (err < 0)
2951 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
2952 else if(err == 1) {
2953 /* Slice could not be decoded in parallel mode, copy down
2954 * NAL unit stuff to context 0 and restart. Note that
1412060e 2955 * rbsp_buffer is not transferred, but since we no longer
afebe2f7
2956 * run in parallel mode this should not be an issue. */
2957 h->nal_unit_type = hx->nal_unit_type;
2958 h->nal_ref_idc = hx->nal_ref_idc;
2959 hx = h;
2960 goto again;
2961 }
2962 }
2963 if(context_count)
2964 execute_decode_slices(h, context_count);
0da71265
MN
2965 return buf_index;
2966}
2967
2968/**
3b66c4c5 2969 * returns the number of bytes consumed for building the current frame
0da71265
MN
2970 */
2971static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
755bfeab 2972 if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
0da71265
MN
2973 if(pos+10>buf_size) pos=buf_size; // oops ;)
2974
2975 return pos;
0da71265
MN
2976}
2977
115329f1 2978static int decode_frame(AVCodecContext *avctx,
0da71265 2979 void *data, int *data_size,
7a00bbad 2980 AVPacket *avpkt)
0da71265 2981{
7a00bbad
TB
2982 const uint8_t *buf = avpkt->data;
2983 int buf_size = avpkt->size;
0da71265
MN
2984 H264Context *h = avctx->priv_data;
2985 MpegEncContext *s = &h->s;
115329f1 2986 AVFrame *pict = data;
0da71265 2987 int buf_index;
115329f1 2988
0da71265 2989 s->flags= avctx->flags;
303e50e6 2990 s->flags2= avctx->flags2;
0da71265 2991
1412060e 2992 /* end of stream, output what is still in the buffers */
0da71265 2993 if (buf_size == 0) {
97bbb885
MN
2994 Picture *out;
2995 int i, out_idx;
2996
2997//FIXME factorize this with the output code below
2998 out = h->delayed_pic[0];
2999 out_idx = 0;
c173a088 3000 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
97bbb885
MN
3001 if(h->delayed_pic[i]->poc < out->poc){
3002 out = h->delayed_pic[i];
3003 out_idx = i;
3004 }
3005
3006 for(i=out_idx; h->delayed_pic[i]; i++)
3007 h->delayed_pic[i] = h->delayed_pic[i+1];
3008
3009 if(out){
3010 *data_size = sizeof(AVFrame);
3011 *pict= *(AVFrame*)out;
3012 }
3013
0da71265
MN
3014 return 0;
3015 }
115329f1 3016
0da71265 3017 buf_index=decode_nal_units(h, buf, buf_size);
115329f1 3018 if(buf_index < 0)
0da71265
MN
3019 return -1;
3020
56c70e1d 3021 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){
1c746a49 3022 if (avctx->skip_frame >= AVDISCARD_NONREF || s->hurry_up) return 0;
56c70e1d
MN
3023 av_log(avctx, AV_LOG_ERROR, "no frame!\n");
3024 return -1;
3025 }
3026
66a4b2c1
MN
3027 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){
3028 Picture *out = s->current_picture_ptr;
3029 Picture *cur = s->current_picture_ptr;
44be1d64 3030 int i, pics, out_of_order, out_idx;
115329f1 3031
256299d3 3032 field_end(h);
66a4b2c1 3033
357282c6 3034 if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
12d96de3
JD
3035 /* Wait for second field. */
3036 *data_size = 0;
3037
3038 } else {
b19d493f 3039 cur->interlaced_frame = 0;
b09a7c05
3040 cur->repeat_pict = 0;
3041
3042 /* Signal interlacing information externally. */
3043 /* Prioritize picture timing SEI information over used decoding process if it exists. */
70e01da3 3044
b09a7c05
3045 if(h->sps.pic_struct_present_flag){
3046 switch (h->sei_pic_struct)
3047 {
b19d493f
HY
3048 case SEI_PIC_STRUCT_FRAME:
3049 break;
3050 case SEI_PIC_STRUCT_TOP_FIELD:
3051 case SEI_PIC_STRUCT_BOTTOM_FIELD:
3052 cur->interlaced_frame = 1;
3053 break;
3054 case SEI_PIC_STRUCT_TOP_BOTTOM:
3055 case SEI_PIC_STRUCT_BOTTOM_TOP:
3056 if (FIELD_OR_MBAFF_PICTURE)
3057 cur->interlaced_frame = 1;
3058 else
3059 // try to flag soft telecine progressive
3060 cur->interlaced_frame = h->prev_interlaced_frame;
3061 break;
b09a7c05
3062 case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
3063 case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
3064 // Signal the possibility of telecined film externally (pic_struct 5,6)
3065 // From these hints, let the applications decide if they apply deinterlacing.
3066 cur->repeat_pict = 1;
b09a7c05
3067 break;
3068 case SEI_PIC_STRUCT_FRAME_DOUBLING:
3069 // Force progressive here, as doubling interlaced frame is a bad idea.
b09a7c05
3070 cur->repeat_pict = 2;
3071 break;
3072 case SEI_PIC_STRUCT_FRAME_TRIPLING:
b09a7c05
3073 cur->repeat_pict = 4;
3074 break;
3075 }
b19d493f
HY
3076
3077 if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
3078 cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;
b09a7c05
3079 }else{
3080 /* Derive interlacing flag from used decoding process. */
3081 cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
3082 }
b19d493f 3083 h->prev_interlaced_frame = cur->interlaced_frame;
b09a7c05
3084
3085 if (cur->field_poc[0] != cur->field_poc[1]){
3086 /* Derive top_field_first from field pocs. */
3087 cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];
3088 }else{
3089 if(cur->interlaced_frame || h->sps.pic_struct_present_flag){
3090 /* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */
3091 if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM
3092 || h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
3093 cur->top_field_first = 1;
3094 else
3095 cur->top_field_first = 0;
3096 }else{
3097 /* Most likely progressive */
3098 cur->top_field_first = 0;
3099 }
3100 }
84a8596d 3101
f6e3c460 3102 //FIXME do something with unavailable reference frames
8b92b792 3103
f6e3c460 3104 /* Sort B-frames into display order */
2f944356 3105
f6e3c460
3106 if(h->sps.bitstream_restriction_flag
3107 && s->avctx->has_b_frames < h->sps.num_reorder_frames){
3108 s->avctx->has_b_frames = h->sps.num_reorder_frames;
3109 s->low_delay = 0;
3110 }
9170e345 3111
fb19e144
MN
3112 if( s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT
3113 && !h->sps.bitstream_restriction_flag){
3114 s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;
3115 s->low_delay= 0;
3116 }
3117
f6e3c460
3118 pics = 0;
3119 while(h->delayed_pic[pics]) pics++;
9170e345 3120
64b9d48f 3121 assert(pics <= MAX_DELAYED_PIC_COUNT);
4e4d983e 3122
f6e3c460
3123 h->delayed_pic[pics++] = cur;
3124 if(cur->reference == 0)
3125 cur->reference = DELAYED_PIC_REF;
2f944356 3126
f6e3c460
3127 out = h->delayed_pic[0];
3128 out_idx = 0;
c173a088 3129 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
f6e3c460
3130 if(h->delayed_pic[i]->poc < out->poc){
3131 out = h->delayed_pic[i];
3132 out_idx = i;
3133 }
44be1d64
MN
3134 if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))
3135 h->outputed_poc= INT_MIN;
3136 out_of_order = out->poc < h->outputed_poc;
1b547aba 3137
f6e3c460
3138 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
3139 { }
2a811db2 3140 else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)
f6e3c460 3141 || (s->low_delay &&
44be1d64 3142 ((h->outputed_poc != INT_MIN && out->poc > h->outputed_poc + 2)
9701840b 3143 || cur->pict_type == FF_B_TYPE)))
f6e3c460
3144 {
3145 s->low_delay = 0;
3146 s->avctx->has_b_frames++;
f6e3c460 3147 }
f6e3c460
3148
3149 if(out_of_order || pics > s->avctx->has_b_frames){
3eaa6d0e 3150 out->reference &= ~DELAYED_PIC_REF;
f6e3c460
3151 for(i=out_idx; h->delayed_pic[i]; i++)
3152 h->delayed_pic[i] = h->delayed_pic[i+1];
3153 }
3eaa6d0e 3154 if(!out_of_order && pics > s->avctx->has_b_frames){
f6e3c460 3155 *data_size = sizeof(AVFrame);
df8a7dff 3156
44be1d64
MN
3157 if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {
3158 h->outputed_poc = INT_MIN;
3159 } else
67e362ca 3160 h->outputed_poc = out->poc;
f6e3c460 3161 *pict= *(AVFrame*)out;
3eaa6d0e 3162 }else{
f6e3c460 3163 av_log(avctx, AV_LOG_DEBUG, "no picture\n");
3eaa6d0e 3164 }
12d96de3 3165 }
a4dae92b
LM
3166 }
3167
3165e258 3168 assert(pict->data[0] || !*data_size);
4e4d983e 3169 ff_print_debug_info(s, pict);
0da71265 3170//printf("out %d\n", (int)pict->data[0]);
0da71265 3171