Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264.c @ 154f7bb0

History | View | Annotate | Download (128 KB)

1 0da71265 Michael Niedermayer
/*
2 d5ec00ba Alex Converse
 * H.26L/H.264/AVC/JVT/14496-10/... decoder
3 0da71265 Michael Niedermayer
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 0da71265 Michael Niedermayer
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 0da71265 Michael Niedermayer
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 0da71265 Michael Niedermayer
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 0da71265 Michael Niedermayer
 */
21 115329f1 Diego Biurrun
22 0da71265 Michael Niedermayer
/**
23 ba87f080 Diego Biurrun
 * @file
24 0da71265 Michael Niedermayer
 * H.264 / AVC / MPEG4 part10 codec.
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
 */
27
28 e2983d6e Jason Garrett-Glaser
#include "libavcore/imgutils.h"
29 40e5d31b Gwenole Beauchesne
#include "internal.h"
30 0da71265 Michael Niedermayer
#include "dsputil.h"
31
#include "avcodec.h"
32
#include "mpegvideo.h"
33 26b4fe82 Aurelien Jacobs
#include "h264.h"
34 0da71265 Michael Niedermayer
#include "h264data.h"
35 188d3c51 Michael Niedermayer
#include "h264_mvpred.h"
36 0da71265 Michael Niedermayer
#include "golomb.h"
37 199436b9 Aurelien Jacobs
#include "mathops.h"
38 626464fb Kostya Shishkov
#include "rectangle.h"
39 369122dd NVIDIA Corporation
#include "vdpau_internal.h"
40 cfa5a81e Michael Niedermayer
#include "libavutil/avassert.h"
41 0da71265 Michael Niedermayer
42 e5017ab8 Laurent Aimar
#include "cabac.h"
43
44 2848ce84 Loren Merritt
//#undef NDEBUG
45 0da71265 Michael Niedermayer
#include <assert.h>
46
47 d9ec210b Diego Pettenò
static const uint8_t rem6[52]={
48 acd8d10f Panagiotis Issaris
0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
49
};
50
51 d9ec210b Diego Pettenò
static const uint8_t div6[52]={
52 acd8d10f Panagiotis Issaris
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
53
};
54
55 0435fb16 Baptiste Coudurier
static const enum PixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = {
56
    PIX_FMT_DXVA2_VLD,
57
    PIX_FMT_VAAPI_VLD,
58
    PIX_FMT_YUVJ420P,
59
    PIX_FMT_NONE
60
};
61
62 903d58f6 Michael Niedermayer
void ff_h264_write_back_intra_pred_mode(H264Context *h){
63 5b0fb524 Michael Niedermayer
    int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
64 0da71265 Michael Niedermayer
65 662a5b23 Michael Niedermayer
    AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
66
    mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
67
    mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
68
    mode[6]= h->intra4x4_pred_mode_cache[7+8*1];
69 0da71265 Michael Niedermayer
}
70
71
/**
72
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
73
 */
74 2bedc0e8 Michael Niedermayer
int ff_h264_check_intra4x4_pred_mode(H264Context *h){
75
    MpegEncContext * const s = &h->s;
76
    static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
77
    static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
78
    int i;
79
80
    if(!(h->top_samples_available&0x8000)){
81
        for(i=0; i<4; i++){
82
            int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
83
            if(status<0){
84
                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);
85
                return -1;
86
            } else if(status){
87
                h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
88
            }
89
        }
90
    }
91
92
    if((h->left_samples_available&0x8888)!=0x8888){
93
        static const int mask[4]={0x8000,0x2000,0x80,0x20};
94
        for(i=0; i<4; i++){
95
            if(!(h->left_samples_available&mask[i])){
96
                int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
97
                if(status<0){
98
                    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);
99
                    return -1;
100
                } else if(status){
101
                    h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
102
                }
103
            }
104
        }
105
    }
106
107
    return 0;
108
} //FIXME cleanup like ff_h264_check_intra_pred_mode
109
110
/**
111
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
112
 */
113 903d58f6 Michael Niedermayer
int ff_h264_check_intra_pred_mode(H264Context *h, int mode){
114 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
115
    static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
116
    static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
117 115329f1 Diego Biurrun
118 43ff0714 Michael Niedermayer
    if(mode > 6U) {
119 5175b937 Loic Le Loarer
        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);
120 7440fe83 Michael Niedermayer
        return -1;
121 5175b937 Loic Le Loarer
    }
122 115329f1 Diego Biurrun
123 0da71265 Michael Niedermayer
    if(!(h->top_samples_available&0x8000)){
124
        mode= top[ mode ];
125
        if(mode<0){
126 9b879566 Michel Bardiaux
            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);
127 0da71265 Michael Niedermayer
            return -1;
128
        }
129
    }
130 115329f1 Diego Biurrun
131 d1d10e91 Michael Niedermayer
    if((h->left_samples_available&0x8080) != 0x8080){
132 0da71265 Michael Niedermayer
        mode= left[ mode ];
133 d1d10e91 Michael Niedermayer
        if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
134
            mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
135
        }
136 0da71265 Michael Niedermayer
        if(mode<0){
137 9b879566 Michel Bardiaux
            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);
138 0da71265 Michael Niedermayer
            return -1;
139 115329f1 Diego Biurrun
        }
140 0da71265 Michael Niedermayer
    }
141
142
    return mode;
143
}
144
145 1790a5e9 Ivan Schreter
const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
146 0da71265 Michael Niedermayer
    int i, si, di;
147
    uint8_t *dst;
148 24456882 Andreas Öman
    int bufidx;
149 0da71265 Michael Niedermayer
150 bb270c08 Diego Biurrun
//    src[0]&0x80;                //forbidden bit
151 0da71265 Michael Niedermayer
    h->nal_ref_idc= src[0]>>5;
152
    h->nal_unit_type= src[0]&0x1F;
153
154
    src++; length--;
155 115329f1 Diego Biurrun
#if 0
156 0da71265 Michael Niedermayer
    for(i=0; i<length; i++)
157
        printf("%2X ", src[i]);
158
#endif
159 e08715d3 Michael Niedermayer
160 b250f9c6 Aurelien Jacobs
#if HAVE_FAST_UNALIGNED
161
# if HAVE_FAST_64BIT
162 e08715d3 Michael Niedermayer
#   define RS 7
163
    for(i=0; i+1<length; i+=9){
164 19769ece Måns Rullgård
        if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))
165 e08715d3 Michael Niedermayer
# else
166
#   define RS 3
167
    for(i=0; i+1<length; i+=5){
168 19769ece Måns Rullgård
        if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U))
169 e08715d3 Michael Niedermayer
# endif
170
            continue;
171
        if(i>0 && !src[i]) i--;
172
        while(src[i]) i++;
173
#else
174
#   define RS 0
175 0da71265 Michael Niedermayer
    for(i=0; i+1<length; i+=2){
176
        if(src[i]) continue;
177
        if(i>0 && src[i-1]==0) i--;
178 e08715d3 Michael Niedermayer
#endif
179 0da71265 Michael Niedermayer
        if(i+2<length && src[i+1]==0 && src[i+2]<=3){
180
            if(src[i+2]!=3){
181
                /* startcode, so we must be past the end */
182
                length=i;
183
            }
184
            break;
185
        }
186 abb27cfb Michael Niedermayer
        i-= RS;
187 0da71265 Michael Niedermayer
    }
188
189
    if(i>=length-1){ //no escaped 0
190
        *dst_length= length;
191
        *consumed= length+1; //+1 for the header
192 115329f1 Diego Biurrun
        return src;
193 0da71265 Michael Niedermayer
    }
194
195 24456882 Andreas Öman
    bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
196 238ef6da Reimar Döffinger
    av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
197 24456882 Andreas Öman
    dst= h->rbsp_buffer[bufidx];
198 0da71265 Michael Niedermayer
199 ac658be5 Francois Oligny-Lemieux
    if (dst == NULL){
200
        return NULL;
201
    }
202
203 3b66c4c5 Kevin Baragona
//printf("decoding esc\n");
204 593af7cd Michael Niedermayer
    memcpy(dst, src, i);
205
    si=di=i;
206
    while(si+2<length){
207 0da71265 Michael Niedermayer
        //remove escapes (very rare 1:2^22)
208 593af7cd Michael Niedermayer
        if(src[si+2]>3){
209
            dst[di++]= src[si++];
210
            dst[di++]= src[si++];
211
        }else if(src[si]==0 && src[si+1]==0){
212 0da71265 Michael Niedermayer
            if(src[si+2]==3){ //escape
213
                dst[di++]= 0;
214
                dst[di++]= 0;
215
                si+=3;
216 c8470cc1 Michael Niedermayer
                continue;
217 0da71265 Michael Niedermayer
            }else //next start code
218 593af7cd Michael Niedermayer
                goto nsc;
219 0da71265 Michael Niedermayer
        }
220
221
        dst[di++]= src[si++];
222
    }
223 593af7cd Michael Niedermayer
    while(si<length)
224
        dst[di++]= src[si++];
225
nsc:
226 0da71265 Michael Niedermayer
227 d4369630 Alexander Strange
    memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
228
229 0da71265 Michael Niedermayer
    *dst_length= di;
230
    *consumed= si + 1;//+1 for the header
231 90b5b51e Diego Biurrun
//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
232 0da71265 Michael Niedermayer
    return dst;
233
}
234
235 12324121 Diego Elio Pettenò
/**
236
 * Identify the exact end of the bitstream
237
 * @return the length of the trailing, or 0 if damaged
238
 */
239
static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){
240 0da71265 Michael Niedermayer
    int v= *src;
241
    int r;
242
243 a9c9a240 Michel Bardiaux
    tprintf(h->s.avctx, "rbsp trailing %X\n", v);
244 0da71265 Michael Niedermayer
245
    for(r=1; r<9; r++){
246
        if(v&1) return r;
247
        v>>=1;
248
    }
249
    return 0;
250
}
251
252 772225c0 Ronald S. Bultje
#if 0
253
/**
254
 * DCT transforms the 16 dc values.
255
 * @param qp quantization parameter ??? FIXME
256
 */
257
static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
258
//    const int qmul= dequant_coeff[qp][0];
259
    int i;
260
    int temp[16]; //FIXME check if this is a good idea
261
    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
262
    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
263

264
    for(i=0; i<4; i++){
265
        const int offset= y_offset[i];
266
        const int z0= block[offset+stride*0] + block[offset+stride*4];
267
        const int z1= block[offset+stride*0] - block[offset+stride*4];
268
        const int z2= block[offset+stride*1] - block[offset+stride*5];
269
        const int z3= block[offset+stride*1] + block[offset+stride*5];
270

271
        temp[4*i+0]= z0+z3;
272
        temp[4*i+1]= z1+z2;
273
        temp[4*i+2]= z1-z2;
274
        temp[4*i+3]= z0-z3;
275
    }
276

277
    for(i=0; i<4; i++){
278
        const int offset= x_offset[i];
279
        const int z0= temp[4*0+i] + temp[4*2+i];
280
        const int z1= temp[4*0+i] - temp[4*2+i];
281
        const int z2= temp[4*1+i] - temp[4*3+i];
282
        const int z3= temp[4*1+i] + temp[4*3+i];
283

284
        block[stride*0 +offset]= (z0 + z3)>>1;
285
        block[stride*2 +offset]= (z1 + z2)>>1;
286
        block[stride*8 +offset]= (z1 - z2)>>1;
287
        block[stride*10+offset]= (z0 - z3)>>1;
288
    }
289
}
290
#endif
291
292
#undef xStride
293
#undef stride
294
295
static void chroma_dc_dequant_idct_c(DCTELEM *block, int qmul){
296
    const int stride= 16*2;
297
    const int xStride= 16;
298
    int a,b,c,d,e;
299
300
    a= block[stride*0 + xStride*0];
301
    b= block[stride*0 + xStride*1];
302
    c= block[stride*1 + xStride*0];
303
    d= block[stride*1 + xStride*1];
304
305
    e= a-b;
306
    a= a+b;
307
    b= c-d;
308
    c= c+d;
309
310
    block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
311
    block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
312
    block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
313
    block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
314
}
315
316
#if 0
317
static void chroma_dc_dct_c(DCTELEM *block){
318
    const int stride= 16*2;
319
    const int xStride= 16;
320
    int a,b,c,d,e;
321

322
    a= block[stride*0 + xStride*0];
323
    b= block[stride*0 + xStride*1];
324
    c= block[stride*1 + xStride*0];
325
    d= block[stride*1 + xStride*1];
326

327
    e= a-b;
328
    a= a+b;
329
    b= c-d;
330
    c= c+d;
331

332
    block[stride*0 + xStride*0]= (a+c);
333
    block[stride*0 + xStride*1]= (e+b);
334
    block[stride*1 + xStride*0]= (a-c);
335
    block[stride*1 + xStride*1]= (e-b);
336
}
337
#endif
338
339 0da71265 Michael Niedermayer
static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
340
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
341
                           int src_x_offset, int src_y_offset,
342
                           qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
343
    MpegEncContext * const s = &h->s;
344
    const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
345 5d18eaad Loren Merritt
    int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
346 0da71265 Michael Niedermayer
    const int luma_xy= (mx&3) + ((my&3)<<2);
347 5d18eaad Loren Merritt
    uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
348
    uint8_t * src_cb, * src_cr;
349
    int extra_width= h->emu_edge_width;
350
    int extra_height= h->emu_edge_height;
351 0da71265 Michael Niedermayer
    int emu=0;
352
    const int full_mx= mx>>2;
353
    const int full_my= my>>2;
354 fbd312fd Loren Merritt
    const int pic_width  = 16*s->mb_width;
355 0d43dd8c Jeff Downs
    const int pic_height = 16*s->mb_height >> MB_FIELD;
356 115329f1 Diego Biurrun
357 0da71265 Michael Niedermayer
    if(mx&7) extra_width -= 3;
358
    if(my&7) extra_height -= 3;
359 115329f1 Diego Biurrun
360
    if(   full_mx < 0-extra_width
361
       || full_my < 0-extra_height
362
       || full_mx + 16/*FIXME*/ > pic_width + extra_width
363 fbd312fd Loren Merritt
       || full_my + 16/*FIXME*/ > pic_height + extra_height){
364 d23e3e5f Ronald S. Bultje
        s->dsp.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);
365 5d18eaad Loren Merritt
            src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
366 0da71265 Michael Niedermayer
        emu=1;
367
    }
368 115329f1 Diego Biurrun
369 5d18eaad Loren Merritt
    qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
370 0da71265 Michael Niedermayer
    if(!square){
371 5d18eaad Loren Merritt
        qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
372 0da71265 Michael Niedermayer
    }
373 115329f1 Diego Biurrun
374 49fb20cb Aurelien Jacobs
    if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
375 115329f1 Diego Biurrun
376 0d43dd8c Jeff Downs
    if(MB_FIELD){
377 5d18eaad Loren Merritt
        // chroma offset when predicting from a field of opposite parity
378 2143b118 Jeff Downs
        my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
379 5d18eaad Loren Merritt
        emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
380
    }
381
    src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
382
    src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
383
384 0da71265 Michael Niedermayer
    if(emu){
385 d23e3e5f Ronald S. Bultje
        s->dsp.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);
386 0da71265 Michael Niedermayer
            src_cb= s->edge_emu_buffer;
387
    }
388 5d18eaad Loren Merritt
    chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
389 0da71265 Michael Niedermayer
390
    if(emu){
391 d23e3e5f Ronald S. Bultje
        s->dsp.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);
392 0da71265 Michael Niedermayer
            src_cr= s->edge_emu_buffer;
393
    }
394 5d18eaad Loren Merritt
    chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
395 0da71265 Michael Niedermayer
}
396
397 9f2d1b4f Loren Merritt
static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
398 0da71265 Michael Niedermayer
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
399
                           int x_offset, int y_offset,
400
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
401
                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
402
                           int list0, int list1){
403
    MpegEncContext * const s = &h->s;
404
    qpel_mc_func *qpix_op=  qpix_put;
405
    h264_chroma_mc_func chroma_op= chroma_put;
406 115329f1 Diego Biurrun
407 5d18eaad Loren Merritt
    dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;
408
    dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;
409
    dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;
410 0da71265 Michael Niedermayer
    x_offset += 8*s->mb_x;
411 0d43dd8c Jeff Downs
    y_offset += 8*(s->mb_y >> MB_FIELD);
412 115329f1 Diego Biurrun
413 0da71265 Michael Niedermayer
    if(list0){
414 1924f3ce Michael Niedermayer
        Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
415 0da71265 Michael Niedermayer
        mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
416
                           dest_y, dest_cb, dest_cr, x_offset, y_offset,
417
                           qpix_op, chroma_op);
418
419
        qpix_op=  qpix_avg;
420
        chroma_op= chroma_avg;
421
    }
422
423
    if(list1){
424 1924f3ce Michael Niedermayer
        Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
425 0da71265 Michael Niedermayer
        mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
426
                           dest_y, dest_cb, dest_cr, x_offset, y_offset,
427
                           qpix_op, chroma_op);
428
    }
429
}
430
431 9f2d1b4f Loren Merritt
static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
432
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
433
                           int x_offset, int y_offset,
434
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
435
                           h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
436
                           h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
437
                           int list0, int list1){
438
    MpegEncContext * const s = &h->s;
439
440 5d18eaad Loren Merritt
    dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;
441
    dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;
442
    dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;
443 9f2d1b4f Loren Merritt
    x_offset += 8*s->mb_x;
444 0d43dd8c Jeff Downs
    y_offset += 8*(s->mb_y >> MB_FIELD);
445 115329f1 Diego Biurrun
446 9f2d1b4f Loren Merritt
    if(list0 && list1){
447
        /* don't optimize for luma-only case, since B-frames usually
448
         * use implicit weights => chroma too. */
449
        uint8_t *tmp_cb = s->obmc_scratchpad;
450 5d18eaad Loren Merritt
        uint8_t *tmp_cr = s->obmc_scratchpad + 8;
451
        uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;
452 9f2d1b4f Loren Merritt
        int refn0 = h->ref_cache[0][ scan8[n] ];
453
        int refn1 = h->ref_cache[1][ scan8[n] ];
454
455
        mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
456
                    dest_y, dest_cb, dest_cr,
457
                    x_offset, y_offset, qpix_put, chroma_put);
458
        mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
459
                    tmp_y, tmp_cb, tmp_cr,
460
                    x_offset, y_offset, qpix_put, chroma_put);
461
462
        if(h->use_weight == 2){
463 1052b76f Michael Niedermayer
            int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1];
464 9f2d1b4f Loren Merritt
            int weight1 = 64 - weight0;
465 5d18eaad Loren Merritt
            luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);
466
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
467
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
468 9f2d1b4f Loren Merritt
        }else{
469 5d18eaad Loren Merritt
            luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
470 3d9137c8 Michael Niedermayer
                            h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0],
471
                            h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]);
472 5d18eaad Loren Merritt
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
473 3d9137c8 Michael Niedermayer
                            h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0],
474
                            h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]);
475 5d18eaad Loren Merritt
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
476 3d9137c8 Michael Niedermayer
                            h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0],
477
                            h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]);
478 9f2d1b4f Loren Merritt
        }
479
    }else{
480
        int list = list1 ? 1 : 0;
481
        int refn = h->ref_cache[list][ scan8[n] ];
482
        Picture *ref= &h->ref_list[list][refn];
483
        mc_dir_part(h, ref, n, square, chroma_height, delta, list,
484
                    dest_y, dest_cb, dest_cr, x_offset, y_offset,
485
                    qpix_put, chroma_put);
486
487 5d18eaad Loren Merritt
        luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
488 3d9137c8 Michael Niedermayer
                       h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]);
489 9f2d1b4f Loren Merritt
        if(h->use_weight_chroma){
490 5d18eaad Loren Merritt
            chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
491 3d9137c8 Michael Niedermayer
                             h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]);
492 5d18eaad Loren Merritt
            chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
493 3d9137c8 Michael Niedermayer
                             h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]);
494 9f2d1b4f Loren Merritt
        }
495
    }
496
}
497
498
static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
499
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
500
                           int x_offset, int y_offset,
501
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
502
                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
503 115329f1 Diego Biurrun
                           h264_weight_func *weight_op, h264_biweight_func *weight_avg,
504 9f2d1b4f Loren Merritt
                           int list0, int list1){
505
    if((h->use_weight==2 && list0 && list1
506 1052b76f Michael Niedermayer
        && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32))
507 9f2d1b4f Loren Merritt
       || h->use_weight==1)
508
        mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
509
                         x_offset, y_offset, qpix_put, chroma_put,
510
                         weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
511
    else
512
        mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
513
                    x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
514
}
515
516 513fbd8e Loren Merritt
static inline void prefetch_motion(H264Context *h, int list){
517
    /* fetch pixels for estimated mv 4 macroblocks ahead
518
     * optimized for 64byte cache lines */
519
    MpegEncContext * const s = &h->s;
520
    const int refn = h->ref_cache[list][scan8[0]];
521
    if(refn >= 0){
522
        const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
523
        const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
524
        uint8_t **src= h->ref_list[list][refn].data;
525 5d18eaad Loren Merritt
        int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
526 513fbd8e Loren Merritt
        s->dsp.prefetch(src[0]+off, s->linesize, 4);
527
        off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
528
        s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
529
    }
530
}
531
532 0da71265 Michael Niedermayer
static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
533
                      qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
534 9f2d1b4f Loren Merritt
                      qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
535
                      h264_weight_func *weight_op, h264_biweight_func *weight_avg){
536 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
537 64514ee8 Alexander Strange
    const int mb_xy= h->mb_xy;
538 0da71265 Michael Niedermayer
    const int mb_type= s->current_picture.mb_type[mb_xy];
539 115329f1 Diego Biurrun
540 0da71265 Michael Niedermayer
    assert(IS_INTER(mb_type));
541 115329f1 Diego Biurrun
542 513fbd8e Loren Merritt
    prefetch_motion(h, 0);
543
544 0da71265 Michael Niedermayer
    if(IS_16X16(mb_type)){
545
        mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
546
                qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
547 7231ccf4 Michael Niedermayer
                weight_op, weight_avg,
548 0da71265 Michael Niedermayer
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
549
    }else if(IS_16X8(mb_type)){
550
        mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
551
                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
552 9f2d1b4f Loren Merritt
                &weight_op[1], &weight_avg[1],
553 0da71265 Michael Niedermayer
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
554
        mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
555
                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
556 9f2d1b4f Loren Merritt
                &weight_op[1], &weight_avg[1],
557 0da71265 Michael Niedermayer
                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
558
    }else if(IS_8X16(mb_type)){
559 5d18eaad Loren Merritt
        mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
560 0da71265 Michael Niedermayer
                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
561 9f2d1b4f Loren Merritt
                &weight_op[2], &weight_avg[2],
562 0da71265 Michael Niedermayer
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
563 5d18eaad Loren Merritt
        mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
564 0da71265 Michael Niedermayer
                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
565 9f2d1b4f Loren Merritt
                &weight_op[2], &weight_avg[2],
566 0da71265 Michael Niedermayer
                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
567
    }else{
568
        int i;
569 115329f1 Diego Biurrun
570 0da71265 Michael Niedermayer
        assert(IS_8X8(mb_type));
571
572
        for(i=0; i<4; i++){
573
            const int sub_mb_type= h->sub_mb_type[i];
574
            const int n= 4*i;
575
            int x_offset= (i&1)<<2;
576
            int y_offset= (i&2)<<1;
577
578
            if(IS_SUB_8X8(sub_mb_type)){
579
                mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
580
                    qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
581 9f2d1b4f Loren Merritt
                    &weight_op[3], &weight_avg[3],
582 0da71265 Michael Niedermayer
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
583
            }else if(IS_SUB_8X4(sub_mb_type)){
584
                mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
585
                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
586 9f2d1b4f Loren Merritt
                    &weight_op[4], &weight_avg[4],
587 0da71265 Michael Niedermayer
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
588
                mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
589
                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
590 9f2d1b4f Loren Merritt
                    &weight_op[4], &weight_avg[4],
591 0da71265 Michael Niedermayer
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
592
            }else if(IS_SUB_4X8(sub_mb_type)){
593 5d18eaad Loren Merritt
                mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
594 0da71265 Michael Niedermayer
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
595 9f2d1b4f Loren Merritt
                    &weight_op[5], &weight_avg[5],
596 0da71265 Michael Niedermayer
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
597 5d18eaad Loren Merritt
                mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
598 0da71265 Michael Niedermayer
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
599 9f2d1b4f Loren Merritt
                    &weight_op[5], &weight_avg[5],
600 0da71265 Michael Niedermayer
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
601
            }else{
602
                int j;
603
                assert(IS_SUB_4X4(sub_mb_type));
604
                for(j=0; j<4; j++){
605
                    int sub_x_offset= x_offset + 2*(j&1);
606
                    int sub_y_offset= y_offset +   (j&2);
607
                    mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
608
                        qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
609 9f2d1b4f Loren Merritt
                        &weight_op[6], &weight_avg[6],
610 0da71265 Michael Niedermayer
                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
611
                }
612
            }
613
        }
614
    }
615 513fbd8e Loren Merritt
616
    prefetch_motion(h, 1);
617 0da71265 Michael Niedermayer
}
618
619
620 2ed0f766 Ronald S. Bultje
static void free_tables(H264Context *h, int free_rbsp){
621 7978debd Andreas Öman
    int i;
622 afebe2f7 Andreas Öman
    H264Context *hx;
623 0da71265 Michael Niedermayer
    av_freep(&h->intra4x4_pred_mode);
624 e5017ab8 Laurent Aimar
    av_freep(&h->chroma_pred_mode_table);
625
    av_freep(&h->cbp_table);
626 9e528114 Laurent Aimar
    av_freep(&h->mvd_table[0]);
627
    av_freep(&h->mvd_table[1]);
628 5ad984c9 Loren Merritt
    av_freep(&h->direct_table);
629 0da71265 Michael Niedermayer
    av_freep(&h->non_zero_count);
630
    av_freep(&h->slice_table_base);
631
    h->slice_table= NULL;
632 c988f975 Michael Niedermayer
    av_freep(&h->list_counts);
633 e5017ab8 Laurent Aimar
634 0da71265 Michael Niedermayer
    av_freep(&h->mb2b_xy);
635 d43c1922 Michael Niedermayer
    av_freep(&h->mb2br_xy);
636 9f2d1b4f Loren Merritt
637 6752dd5a Reimar Döffinger
    for(i = 0; i < MAX_THREADS; i++) {
638 afebe2f7 Andreas Öman
        hx = h->thread_context[i];
639
        if(!hx) continue;
640
        av_freep(&hx->top_borders[1]);
641
        av_freep(&hx->top_borders[0]);
642
        av_freep(&hx->s.obmc_scratchpad);
643 2ed0f766 Ronald S. Bultje
        if (free_rbsp){
644 fb397b1a Ronald S. Bultje
            av_freep(&hx->rbsp_buffer[1]);
645
            av_freep(&hx->rbsp_buffer[0]);
646
            hx->rbsp_buffer_size[0] = 0;
647
            hx->rbsp_buffer_size[1] = 0;
648 2ed0f766 Ronald S. Bultje
        }
649 d2d5e067 Alexander Strange
        if (i) av_freep(&h->thread_context[i]);
650 afebe2f7 Andreas Öman
    }
651 0da71265 Michael Niedermayer
}
652
653 239ea04c Loren Merritt
static void init_dequant8_coeff_table(H264Context *h){
654
    int i,q,x;
655
    h->dequant8_coeff[0] = h->dequant8_buffer[0];
656
    h->dequant8_coeff[1] = h->dequant8_buffer[1];
657
658
    for(i=0; i<2; i++ ){
659
        if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
660
            h->dequant8_coeff[1] = h->dequant8_buffer[0];
661
            break;
662
        }
663
664
        for(q=0; q<52; q++){
665 d9ec210b Diego Pettenò
            int shift = div6[q];
666
            int idx = rem6[q];
667 239ea04c Loren Merritt
            for(x=0; x<64; x++)
668 ca32f7f2 Jason Garrett-Glaser
                h->dequant8_coeff[i][q][(x>>3)|((x&7)<<3)] =
669 548a1c8a Loren Merritt
                    ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
670
                    h->pps.scaling_matrix8[i][x]) << shift;
671 239ea04c Loren Merritt
        }
672
    }
673
}
674
675
static void init_dequant4_coeff_table(H264Context *h){
676
    int i,j,q,x;
677
    for(i=0; i<6; i++ ){
678
        h->dequant4_coeff[i] = h->dequant4_buffer[i];
679
        for(j=0; j<i; j++){
680
            if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
681
                h->dequant4_coeff[i] = h->dequant4_buffer[j];
682
                break;
683
            }
684
        }
685
        if(j<i)
686
            continue;
687
688
        for(q=0; q<52; q++){
689 d9ec210b Diego Pettenò
            int shift = div6[q] + 2;
690
            int idx = rem6[q];
691 239ea04c Loren Merritt
            for(x=0; x<16; x++)
692 ca32f7f2 Jason Garrett-Glaser
                h->dequant4_coeff[i][q][(x>>2)|((x<<2)&0xF)] =
693 ab2e3e2c Loren Merritt
                    ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
694 239ea04c Loren Merritt
                    h->pps.scaling_matrix4[i][x]) << shift;
695
        }
696
    }
697
}
698
699
static void init_dequant_tables(H264Context *h){
700
    int i,x;
701
    init_dequant4_coeff_table(h);
702
    if(h->pps.transform_8x8_mode)
703
        init_dequant8_coeff_table(h);
704
    if(h->sps.transform_bypass){
705
        for(i=0; i<6; i++)
706
            for(x=0; x<16; x++)
707
                h->dequant4_coeff[i][0][x] = 1<<6;
708
        if(h->pps.transform_8x8_mode)
709
            for(i=0; i<2; i++)
710
                for(x=0; x<64; x++)
711
                    h->dequant8_coeff[i][0][x] = 1<<6;
712
    }
713
}
714
715
716 903d58f6 Michael Niedermayer
int ff_h264_alloc_tables(H264Context *h){
717 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
718 7bc9090a Michael Niedermayer
    const int big_mb_num= s->mb_stride * (s->mb_height+1);
719 145061a1 Michael Niedermayer
    const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;
720 239ea04c Loren Merritt
    int x,y;
721 0da71265 Michael Niedermayer
722 145061a1 Michael Niedermayer
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8  * sizeof(uint8_t), fail)
723 e5017ab8 Laurent Aimar
724 c988f975 Michael Niedermayer
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count    , big_mb_num * 32 * sizeof(uint8_t), fail)
725 d31dbec3 Ramiro Polla
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail)
726
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail)
727 0da71265 Michael Niedermayer
728 d31dbec3 Ramiro Polla
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail)
729 145061a1 Michael Niedermayer
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail);
730
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail);
731 36b54927 Michael Niedermayer
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail);
732 c988f975 Michael Niedermayer
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail)
733 e5017ab8 Laurent Aimar
734 b735aeea Michael Niedermayer
    memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(*h->slice_table_base));
735 5d18eaad Loren Merritt
    h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
736 0da71265 Michael Niedermayer
737 d31dbec3 Ramiro Polla
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy  , big_mb_num * sizeof(uint32_t), fail);
738 d43c1922 Michael Niedermayer
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail);
739 0da71265 Michael Niedermayer
    for(y=0; y<s->mb_height; y++){
740
        for(x=0; x<s->mb_width; x++){
741 7bc9090a Michael Niedermayer
            const int mb_xy= x + y*s->mb_stride;
742 0da71265 Michael Niedermayer
            const int b_xy = 4*x + 4*y*h->b_stride;
743 115329f1 Diego Biurrun
744 0da71265 Michael Niedermayer
            h->mb2b_xy [mb_xy]= b_xy;
745 e1c88a21 Michael Niedermayer
            h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride)));
746 0da71265 Michael Niedermayer
        }
747
    }
748 9f2d1b4f Loren Merritt
749 9c6221ae Gert Vervoort
    s->obmc_scratchpad = NULL;
750
751 56edbd81 Loren Merritt
    if(!h->dequant4_coeff[0])
752
        init_dequant_tables(h);
753
754 0da71265 Michael Niedermayer
    return 0;
755
fail:
756 2ed0f766 Ronald S. Bultje
    free_tables(h, 1);
757 0da71265 Michael Niedermayer
    return -1;
758
}
759
760 afebe2f7 Andreas Öman
/**
761
 * Mimic alloc_tables(), but for every context thread.
762
 */
763 145061a1 Michael Niedermayer
static void clone_tables(H264Context *dst, H264Context *src, int i){
764
    MpegEncContext * const s = &src->s;
765
    dst->intra4x4_pred_mode       = src->intra4x4_pred_mode + i*8*2*s->mb_stride;
766 afebe2f7 Andreas Öman
    dst->non_zero_count           = src->non_zero_count;
767
    dst->slice_table              = src->slice_table;
768
    dst->cbp_table                = src->cbp_table;
769
    dst->mb2b_xy                  = src->mb2b_xy;
770 d43c1922 Michael Niedermayer
    dst->mb2br_xy                 = src->mb2br_xy;
771 afebe2f7 Andreas Öman
    dst->chroma_pred_mode_table   = src->chroma_pred_mode_table;
772 145061a1 Michael Niedermayer
    dst->mvd_table[0]             = src->mvd_table[0] + i*8*2*s->mb_stride;
773
    dst->mvd_table[1]             = src->mvd_table[1] + i*8*2*s->mb_stride;
774 afebe2f7 Andreas Öman
    dst->direct_table             = src->direct_table;
775 fb823b77 Michael Niedermayer
    dst->list_counts              = src->list_counts;
776 afebe2f7 Andreas Öman
777
    dst->s.obmc_scratchpad = NULL;
778
    ff_h264_pred_init(&dst->hpc, src->s.codec_id);
779
}
780
781
/**
782
 * Init context
783
 * Allocate buffers which are not shared amongst multiple threads.
784
 */
785
static int context_init(H264Context *h){
786 d31dbec3 Ramiro Polla
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail)
787
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail)
788 afebe2f7 Andreas Öman
789 145061a1 Michael Niedermayer
    h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =
790
    h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;
791
792 afebe2f7 Andreas Öman
    return 0;
793
fail:
794
    return -1; // free_tables will clean up for us
795
}
796
797 9855b2e3 Michael Niedermayer
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size);
798
799 98a6fff9 Zuxy Meng
static av_cold void common_init(H264Context *h){
800 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
801
802
    s->width = s->avctx->width;
803
    s->height = s->avctx->height;
804
    s->codec_id= s->avctx->codec->id;
805 115329f1 Diego Biurrun
806 4693b031 Måns Rullgård
    ff_h264dsp_init(&h->h264dsp);
807 c92a30bb Kostya Shishkov
    ff_h264_pred_init(&h->hpc, s->codec_id);
808 0da71265 Michael Niedermayer
809 239ea04c Loren Merritt
    h->dequant_coeff_pps= -1;
810 9a41c2c7 Michael Niedermayer
    s->unrestricted_mv=1;
811 0da71265 Michael Niedermayer
    s->decode=1; //FIXME
812 56edbd81 Loren Merritt
813 a5805aa9 Michael Niedermayer
    dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
814
815 56edbd81 Loren Merritt
    memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
816
    memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
817 0da71265 Michael Niedermayer
}
818
819 05e95319 Howard Chu
int ff_h264_decode_extradata(H264Context *h)
820
{
821
    AVCodecContext *avctx = h->s.avctx;
822 9855b2e3 Michael Niedermayer
823 05e95319 Howard Chu
    if(*(char *)avctx->extradata == 1){
824 9855b2e3 Michael Niedermayer
        int i, cnt, nalsize;
825
        unsigned char *p = avctx->extradata;
826
827
        h->is_avc = 1;
828
829
        if(avctx->extradata_size < 7) {
830
            av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
831
            return -1;
832
        }
833
        /* sps and pps in the avcC always have length coded with 2 bytes,
834
           so put a fake nal_length_size = 2 while parsing them */
835
        h->nal_length_size = 2;
836
        // Decode sps from avcC
837
        cnt = *(p+5) & 0x1f; // Number of sps
838
        p += 6;
839
        for (i = 0; i < cnt; i++) {
840
            nalsize = AV_RB16(p) + 2;
841
            if(decode_nal_units(h, p, nalsize) < 0) {
842
                av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
843
                return -1;
844
            }
845
            p += nalsize;
846
        }
847
        // Decode pps from avcC
848
        cnt = *(p++); // Number of pps
849
        for (i = 0; i < cnt; i++) {
850
            nalsize = AV_RB16(p) + 2;
851
            if(decode_nal_units(h, p, nalsize)  != nalsize) {
852
                av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
853
                return -1;
854
            }
855
            p += nalsize;
856
        }
857
        // Now store right nal length size, that will be use to parse all other nals
858
        h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
859
    } else {
860
        h->is_avc = 0;
861 05e95319 Howard Chu
        if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)
862 9855b2e3 Michael Niedermayer
            return -1;
863
    }
864 05e95319 Howard Chu
    return 0;
865
}
866
867
av_cold int ff_h264_decode_init(AVCodecContext *avctx){
868
    H264Context *h= avctx->priv_data;
869
    MpegEncContext * const s = &h->s;
870
871
    MPV_decode_defaults(s);
872
873
    s->avctx = avctx;
874
    common_init(h);
875
876
    s->out_format = FMT_H264;
877
    s->workaround_bugs= avctx->workaround_bugs;
878
879
    // set defaults
880
//    s->decode_mb= ff_h263_decode_mb;
881
    s->quarter_sample = 1;
882
    if(!avctx->has_b_frames)
883
    s->low_delay= 1;
884
885
    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
886
887
    ff_h264_decode_init_vlc();
888
889
    h->thread_context[0] = h;
890
    h->outputed_poc = INT_MIN;
891
    h->prev_poc_msb= 1<<16;
892
    h->x264_build = -1;
893
    ff_h264_reset_sei(h);
894
    if(avctx->codec_id == CODEC_ID_H264){
895
        if(avctx->ticks_per_frame == 1){
896
            s->avctx->time_base.den *=2;
897
        }
898
        avctx->ticks_per_frame = 2;
899
    }
900
901
    if(avctx->extradata_size > 0 && avctx->extradata &&
902
        ff_h264_decode_extradata(h))
903
        return -1;
904
905 db8cb47d Michael Niedermayer
    if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){
906
        s->avctx->has_b_frames = h->sps.num_reorder_frames;
907
        s->low_delay = 0;
908
    }
909 9855b2e3 Michael Niedermayer
910 0da71265 Michael Niedermayer
    return 0;
911
}
912
913 903d58f6 Michael Niedermayer
int ff_h264_frame_start(H264Context *h){
914 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
915
    int i;
916
917 af8aa846 Michael Niedermayer
    if(MPV_frame_start(s, s->avctx) < 0)
918
        return -1;
919 0da71265 Michael Niedermayer
    ff_er_frame_start(s);
920 3a22d7fa Jeff Downs
    /*
921
     * MPV_frame_start uses pict_type to derive key_frame.
922
     * This is incorrect for H.264; IDR markings must be used.
923 1412060e Diego Biurrun
     * Zero here; IDR markings per slice in frame or fields are ORed in later.
924 3a22d7fa Jeff Downs
     * See decode_nal_units().
925
     */
926
    s->current_picture_ptr->key_frame= 0;
927 c173a088 Haruhiko Yamagata
    s->current_picture_ptr->mmco_reset= 0;
928 0da71265 Michael Niedermayer
929
    assert(s->linesize && s->uvlinesize);
930
931
    for(i=0; i<16; i++){
932
        h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
933 6867a90b Loic Le Loarer
        h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
934 0da71265 Michael Niedermayer
    }
935
    for(i=0; i<4; i++){
936
        h->block_offset[16+i]=
937
        h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
938 6867a90b Loic Le Loarer
        h->block_offset[24+16+i]=
939
        h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
940 0da71265 Michael Niedermayer
    }
941
942 934b0821 Loren Merritt
    /* can't be in alloc_tables because linesize isn't known there.
943
     * FIXME: redo bipred weight to not require extra buffer? */
944 afebe2f7 Andreas Öman
    for(i = 0; i < s->avctx->thread_count; i++)
945 0f016023 Alexander Strange
        if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)
946 afebe2f7 Andreas Öman
            h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
947 5d18eaad Loren Merritt
948 2ce1c2e0 Michael Niedermayer
    /* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/
949 5820b90d Michael Niedermayer
    memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
950 934b0821 Loren Merritt
951 0da71265 Michael Niedermayer
//    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
952 28bb9eb2 Michael Niedermayer
953 1412060e Diego Biurrun
    // We mark the current picture as non-reference after allocating it, so
954 28bb9eb2 Michael Niedermayer
    // that if we break out due to an error it can be released automatically
955
    // in the next MPV_frame_start().
956
    // SVQ3 as well as most other codecs have only last/next/current and thus
957
    // get released even with set reference, besides SVQ3 and others do not
958
    // mark frames as reference later "naturally".
959
    if(s->codec_id != CODEC_ID_SVQ3)
960
        s->current_picture_ptr->reference= 0;
961 357282c6 Michael Niedermayer
962
    s->current_picture_ptr->field_poc[0]=
963
    s->current_picture_ptr->field_poc[1]= INT_MAX;
964 5118c6c7 Michael Niedermayer
    assert(s->current_picture_ptr->long_ref==0);
965 357282c6 Michael Niedermayer
966 af8aa846 Michael Niedermayer
    return 0;
967 0da71265 Michael Niedermayer
}
968
969 93cc10fa Andreas Öman
static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){
970 53c05b1e Michael Niedermayer
    MpegEncContext * const s = &h->s;
971 0b69d625 Alexander Strange
    uint8_t *top_border;
972 5f7f9719 Michael Niedermayer
    int top_idx = 1;
973 115329f1 Diego Biurrun
974 53c05b1e Michael Niedermayer
    src_y  -=   linesize;
975
    src_cb -= uvlinesize;
976
    src_cr -= uvlinesize;
977
978 5f7f9719 Michael Niedermayer
    if(!simple && FRAME_MBAFF){
979
        if(s->mb_y&1){
980
            if(!MB_MBAFF){
981 0b69d625 Alexander Strange
                top_border = h->top_borders[0][s->mb_x];
982
                AV_COPY128(top_border, src_y + 15*linesize);
983 49fb20cb Aurelien Jacobs
                if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
984 0b69d625 Alexander Strange
                    AV_COPY64(top_border+16, src_cb+7*uvlinesize);
985
                    AV_COPY64(top_border+24, src_cr+7*uvlinesize);
986 5f7f9719 Michael Niedermayer
                }
987
            }
988 c988f975 Michael Niedermayer
        }else if(MB_MBAFF){
989
            top_idx = 0;
990
        }else
991
            return;
992 5f7f9719 Michael Niedermayer
    }
993
994 0b69d625 Alexander Strange
    top_border = h->top_borders[top_idx][s->mb_x];
995 3b66c4c5 Kevin Baragona
    // There are two lines saved, the line above the the top macroblock of a pair,
996 6867a90b Loic Le Loarer
    // and the line above the bottom macroblock
997 0b69d625 Alexander Strange
    AV_COPY128(top_border, src_y + 16*linesize);
998 53c05b1e Michael Niedermayer
999 49fb20cb Aurelien Jacobs
    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1000 0b69d625 Alexander Strange
        AV_COPY64(top_border+16, src_cb+8*uvlinesize);
1001
        AV_COPY64(top_border+24, src_cr+8*uvlinesize);
1002 53c05b1e Michael Niedermayer
    }
1003
}
1004
1005 93cc10fa Andreas Öman
static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int simple){
1006 53c05b1e Michael Niedermayer
    MpegEncContext * const s = &h->s;
1007 b69378e2 Andreas Öman
    int deblock_left;
1008
    int deblock_top;
1009 5f7f9719 Michael Niedermayer
    int top_idx = 1;
1010 1e4f1c56 Alexander Strange
    uint8_t *top_border_m1;
1011
    uint8_t *top_border;
1012 5f7f9719 Michael Niedermayer
1013
    if(!simple && FRAME_MBAFF){
1014
        if(s->mb_y&1){
1015 c988f975 Michael Niedermayer
            if(!MB_MBAFF)
1016
                return;
1017 5f7f9719 Michael Niedermayer
        }else{
1018
            top_idx = MB_MBAFF ? 0 : 1;
1019
        }
1020
    }
1021 b69378e2 Andreas Öman
1022
    if(h->deblocking_filter == 2) {
1023 024bf79f Michael Niedermayer
        deblock_left = h->left_type[0];
1024
        deblock_top  = h->top_type;
1025 b69378e2 Andreas Öman
    } else {
1026
        deblock_left = (s->mb_x > 0);
1027 6c805007 Michael Niedermayer
        deblock_top =  (s->mb_y > !!MB_FIELD);
1028 b69378e2 Andreas Öman
    }
1029 53c05b1e Michael Niedermayer
1030
    src_y  -=   linesize + 1;
1031
    src_cb -= uvlinesize + 1;
1032
    src_cr -= uvlinesize + 1;
1033
1034 1e4f1c56 Alexander Strange
    top_border_m1 = h->top_borders[top_idx][s->mb_x-1];
1035
    top_border    = h->top_borders[top_idx][s->mb_x];
1036
1037 0b69d625 Alexander Strange
#define XCHG(a,b,xchg)\
1038
if (xchg) AV_SWAP64(b,a);\
1039
else      AV_COPY64(b,a);
1040 d89dc06a Loren Merritt
1041
    if(deblock_top){
1042 c988f975 Michael Niedermayer
        if(deblock_left){
1043 0b69d625 Alexander Strange
            XCHG(top_border_m1+8, src_y -7, 1);
1044 c988f975 Michael Niedermayer
        }
1045 0b69d625 Alexander Strange
        XCHG(top_border+0, src_y +1, xchg);
1046
        XCHG(top_border+8, src_y +9, 1);
1047 cad4368a Reimar Döffinger
        if(s->mb_x+1 < s->mb_width){
1048 0b69d625 Alexander Strange
            XCHG(h->top_borders[top_idx][s->mb_x+1], src_y +17, 1);
1049 43efd19a Loren Merritt
        }
1050 53c05b1e Michael Niedermayer
    }
1051
1052 49fb20cb Aurelien Jacobs
    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1053 d89dc06a Loren Merritt
        if(deblock_top){
1054 c988f975 Michael Niedermayer
            if(deblock_left){
1055 0b69d625 Alexander Strange
                XCHG(top_border_m1+16, src_cb -7, 1);
1056
                XCHG(top_border_m1+24, src_cr -7, 1);
1057 c988f975 Michael Niedermayer
            }
1058 0b69d625 Alexander Strange
            XCHG(top_border+16, src_cb+1, 1);
1059
            XCHG(top_border+24, src_cr+1, 1);
1060 53c05b1e Michael Niedermayer
        }
1061
    }
1062
}
1063
1064 5a6a6cc7 Diego Biurrun
static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){
1065 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
1066
    const int mb_x= s->mb_x;
1067
    const int mb_y= s->mb_y;
1068 64514ee8 Alexander Strange
    const int mb_xy= h->mb_xy;
1069 0da71265 Michael Niedermayer
    const int mb_type= s->current_picture.mb_type[mb_xy];
1070
    uint8_t  *dest_y, *dest_cb, *dest_cr;
1071
    int linesize, uvlinesize /*dct_offset*/;
1072
    int i;
1073 6867a90b Loic Le Loarer
    int *block_offset = &h->block_offset[0];
1074 41e4055b Michael Niedermayer
    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
1075 8b6871ed Diego Biurrun
    /* is_h264 should always be true if SVQ3 is disabled. */
1076 49fb20cb Aurelien Jacobs
    const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;
1077 36940eca Loren Merritt
    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
1078 ef9d1d15 Loren Merritt
    void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
1079 0da71265 Michael Niedermayer
1080 6120a343 Michael Niedermayer
    dest_y  = s->current_picture.data[0] + (mb_x + mb_y * s->linesize  ) * 16;
1081
    dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
1082
    dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
1083 0da71265 Michael Niedermayer
1084 a957c27b Loren Merritt
    s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
1085
    s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);
1086
1087 c988f975 Michael Niedermayer
    h->list_counts[mb_xy]= h->list_count;
1088
1089 bd91fee3 Alexander Strange
    if (!simple && MB_FIELD) {
1090 5d18eaad Loren Merritt
        linesize   = h->mb_linesize   = s->linesize * 2;
1091
        uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
1092 6867a90b Loic Le Loarer
        block_offset = &h->block_offset[24];
1093 1412060e Diego Biurrun
        if(mb_y&1){ //FIXME move out of this function?
1094 0da71265 Michael Niedermayer
            dest_y -= s->linesize*15;
1095 6867a90b Loic Le Loarer
            dest_cb-= s->uvlinesize*7;
1096
            dest_cr-= s->uvlinesize*7;
1097 0da71265 Michael Niedermayer
        }
1098 5d18eaad Loren Merritt
        if(FRAME_MBAFF) {
1099
            int list;
1100 3425501d Michael Niedermayer
            for(list=0; list<h->list_count; list++){
1101 5d18eaad Loren Merritt
                if(!USES_LIST(mb_type, list))
1102
                    continue;
1103
                if(IS_16X16(mb_type)){
1104
                    int8_t *ref = &h->ref_cache[list][scan8[0]];
1105 1710856c Andreas Öman
                    fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
1106 5d18eaad Loren Merritt
                }else{
1107
                    for(i=0; i<16; i+=4){
1108
                        int ref = h->ref_cache[list][scan8[i]];
1109
                        if(ref >= 0)
1110 1710856c Andreas Öman
                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
1111 5d18eaad Loren Merritt
                    }
1112
                }
1113
            }
1114
        }
1115 0da71265 Michael Niedermayer
    } else {
1116 5d18eaad Loren Merritt
        linesize   = h->mb_linesize   = s->linesize;
1117
        uvlinesize = h->mb_uvlinesize = s->uvlinesize;
1118 0da71265 Michael Niedermayer
//        dct_offset = s->linesize * 16;
1119
    }
1120 115329f1 Diego Biurrun
1121 bd91fee3 Alexander Strange
    if (!simple && IS_INTRA_PCM(mb_type)) {
1122 c1708e8d Michael Niedermayer
        for (i=0; i<16; i++) {
1123
            memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);
1124 6fbcaaa0 Loic Le Loarer
        }
1125 c1708e8d Michael Niedermayer
        for (i=0; i<8; i++) {
1126
            memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);
1127
            memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);
1128 6fbcaaa0 Loic Le Loarer
        }
1129 e7e09b49 Loic Le Loarer
    } else {
1130
        if(IS_INTRA(mb_type)){
1131 5f7f9719 Michael Niedermayer
            if(h->deblocking_filter)
1132 93cc10fa Andreas Öman
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
1133 53c05b1e Michael Niedermayer
1134 49fb20cb Aurelien Jacobs
            if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1135 c92a30bb Kostya Shishkov
                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
1136
                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
1137 e7e09b49 Loic Le Loarer
            }
1138 0da71265 Michael Niedermayer
1139 e7e09b49 Loic Le Loarer
            if(IS_INTRA4x4(mb_type)){
1140 bd91fee3 Alexander Strange
                if(simple || !s->encoding){
1141 43efd19a Loren Merritt
                    if(IS_8x8DCT(mb_type)){
1142 1eb96035 Michael Niedermayer
                        if(transform_bypass){
1143
                            idct_dc_add =
1144
                            idct_add    = s->dsp.add_pixels8;
1145 dae006d7 Michael Niedermayer
                        }else{
1146 4693b031 Måns Rullgård
                            idct_dc_add = h->h264dsp.h264_idct8_dc_add;
1147
                            idct_add    = h->h264dsp.h264_idct8_add;
1148 1eb96035 Michael Niedermayer
                        }
1149 43efd19a Loren Merritt
                        for(i=0; i<16; i+=4){
1150
                            uint8_t * const ptr= dest_y + block_offset[i];
1151
                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
1152 41e4055b Michael Niedermayer
                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1153
                                h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);
1154
                            }else{
1155 ac0623b2 Michael Niedermayer
                                const int nnz = h->non_zero_count_cache[ scan8[i] ];
1156
                                h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
1157
                                                            (h->topright_samples_available<<i)&0x4000, linesize);
1158
                                if(nnz){
1159
                                    if(nnz == 1 && h->mb[i*16])
1160
                                        idct_dc_add(ptr, h->mb + i*16, linesize);
1161
                                    else
1162
                                        idct_add   (ptr, h->mb + i*16, linesize);
1163
                                }
1164 41e4055b Michael Niedermayer
                            }
1165 43efd19a Loren Merritt
                        }
1166 1eb96035 Michael Niedermayer
                    }else{
1167
                        if(transform_bypass){
1168
                            idct_dc_add =
1169
                            idct_add    = s->dsp.add_pixels4;
1170
                        }else{
1171 4693b031 Måns Rullgård
                            idct_dc_add = h->h264dsp.h264_idct_dc_add;
1172
                            idct_add    = h->h264dsp.h264_idct_add;
1173 1eb96035 Michael Niedermayer
                        }
1174 aebb5d6d Michael Niedermayer
                        for(i=0; i<16; i++){
1175
                            uint8_t * const ptr= dest_y + block_offset[i];
1176
                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
1177 e7e09b49 Loic Le Loarer
1178 aebb5d6d Michael Niedermayer
                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1179
                                h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
1180
                            }else{
1181
                                uint8_t *topright;
1182
                                int nnz, tr;
1183
                                if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
1184
                                    const int topright_avail= (h->topright_samples_available<<i)&0x8000;
1185
                                    assert(mb_y || linesize <= block_offset[i]);
1186
                                    if(!topright_avail){
1187
                                        tr= ptr[3 - linesize]*0x01010101;
1188
                                        topright= (uint8_t*) &tr;
1189
                                    }else
1190
                                        topright= ptr + 4 - linesize;
1191 ac0623b2 Michael Niedermayer
                                }else
1192 aebb5d6d Michael Niedermayer
                                    topright= NULL;
1193
1194
                                h->hpc.pred4x4[ dir ](ptr, topright, linesize);
1195
                                nnz = h->non_zero_count_cache[ scan8[i] ];
1196
                                if(nnz){
1197
                                    if(is_h264){
1198
                                        if(nnz == 1 && h->mb[i*16])
1199
                                            idct_dc_add(ptr, h->mb + i*16, linesize);
1200
                                        else
1201
                                            idct_add   (ptr, h->mb + i*16, linesize);
1202
                                    }else
1203 881b5b80 Rafaël Carré
                                        ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
1204 aebb5d6d Michael Niedermayer
                                }
1205 ac0623b2 Michael Niedermayer
                            }
1206 41e4055b Michael Niedermayer
                        }
1207 8b82a956 Michael Niedermayer
                    }
1208 0da71265 Michael Niedermayer
                }
1209 e7e09b49 Loic Le Loarer
            }else{
1210 c92a30bb Kostya Shishkov
                h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
1211 2e186601 Jason Garrett-Glaser
                if(is_h264){
1212
                    if(h->non_zero_count_cache[ scan8[LUMA_DC_BLOCK_INDEX] ]){
1213 0d1d01cf Jason Garrett-Glaser
                        if(!transform_bypass)
1214
                            h->h264dsp.h264_luma_dc_dequant_idct(h->mb, h->mb_luma_dc, h->dequant4_coeff[0][s->qscale][0]);
1215
                        else{
1216
                            static const uint8_t dc_mapping[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,
1217
                                                                    8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};
1218
                            for(i = 0; i < 16; i++)
1219
                                h->mb[dc_mapping[i]] = h->mb_luma_dc[i];
1220
                        }
1221 2e186601 Jason Garrett-Glaser
                    }
1222
                }else
1223 290fabc6 Jason Garrett-Glaser
                    ff_svq3_luma_dc_dequant_idct_c(h->mb, h->mb_luma_dc, s->qscale);
1224 0da71265 Michael Niedermayer
            }
1225 5f7f9719 Michael Niedermayer
            if(h->deblocking_filter)
1226 93cc10fa Andreas Öman
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);
1227 bd91fee3 Alexander Strange
        }else if(is_h264){
1228 e7e09b49 Loic Le Loarer
            hl_motion(h, dest_y, dest_cb, dest_cr,
1229 2833fc46 Loren Merritt
                      s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
1230
                      s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
1231 4693b031 Måns Rullgård
                      h->h264dsp.weight_h264_pixels_tab, h->h264dsp.biweight_h264_pixels_tab);
1232 0da71265 Michael Niedermayer
        }
1233 e7e09b49 Loic Le Loarer
1234
1235
        if(!IS_INTRA4x4(mb_type)){
1236 bd91fee3 Alexander Strange
            if(is_h264){
1237 ef9d1d15 Loren Merritt
                if(IS_INTRA16x16(mb_type)){
1238 2fd1f0e0 Michael Niedermayer
                    if(transform_bypass){
1239
                        if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
1240 0a8ca22f Michael Niedermayer
                            h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
1241
                        }else{
1242
                            for(i=0; i<16; i++){
1243
                                if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
1244 1eb96035 Michael Niedermayer
                                    s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize);
1245 0a8ca22f Michael Niedermayer
                            }
1246 2fd1f0e0 Michael Niedermayer
                        }
1247
                    }else{
1248 4693b031 Måns Rullgård
                         h->h264dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
1249 41e4055b Michael Niedermayer
                    }
1250 49c084a7 Michael Niedermayer
                }else if(h->cbp&15){
1251 2fd1f0e0 Michael Niedermayer
                    if(transform_bypass){
1252 0a8ca22f Michael Niedermayer
                        const int di = IS_8x8DCT(mb_type) ? 4 : 1;
1253 1eb96035 Michael Niedermayer
                        idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
1254 0a8ca22f Michael Niedermayer
                        for(i=0; i<16; i+=di){
1255 62bc966f Michael Niedermayer
                            if(h->non_zero_count_cache[ scan8[i] ]){
1256 ef9d1d15 Loren Merritt
                                idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
1257 0a8ca22f Michael Niedermayer
                            }
1258 ef9d1d15 Loren Merritt
                        }
1259 2fd1f0e0 Michael Niedermayer
                    }else{
1260
                        if(IS_8x8DCT(mb_type)){
1261 4693b031 Måns Rullgård
                            h->h264dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
1262 2fd1f0e0 Michael Niedermayer
                        }else{
1263 4693b031 Måns Rullgård
                            h->h264dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
1264 2fd1f0e0 Michael Niedermayer
                        }
1265
                    }
1266 4704097a Michael Niedermayer
                }
1267 e7e09b49 Loic Le Loarer
            }else{
1268
                for(i=0; i<16; i++){
1269
                    if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
1270 6867a90b Loic Le Loarer
                        uint8_t * const ptr= dest_y + block_offset[i];
1271 881b5b80 Rafaël Carré
                        ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
1272 e7e09b49 Loic Le Loarer
                    }
1273 4704097a Michael Niedermayer
                }
1274 0da71265 Michael Niedermayer
            }
1275
        }
1276
1277 49fb20cb Aurelien Jacobs
        if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
1278 ef9d1d15 Loren Merritt
            uint8_t *dest[2] = {dest_cb, dest_cr};
1279
            if(transform_bypass){
1280 96465b90 Michael Niedermayer
                if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
1281
                    h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize);
1282
                    h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize);
1283
                }else{
1284 c25ac15a Michael Niedermayer
                    idct_add = s->dsp.add_pixels4;
1285 96465b90 Michael Niedermayer
                    for(i=16; i<16+8; i++){
1286
                        if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
1287
                            idct_add   (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
1288
                    }
1289
                }
1290 ef9d1d15 Loren Merritt
            }else{
1291 aebb5d6d Michael Niedermayer
                if(is_h264){
1292 2e186601 Jason Garrett-Glaser
                    if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+0] ])
1293 772225c0 Ronald S. Bultje
                        chroma_dc_dequant_idct_c(h->mb + 16*16     , h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
1294 2e186601 Jason Garrett-Glaser
                    if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+1] ])
1295 772225c0 Ronald S. Bultje
                        chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
1296 1d16a1cf Ronald S. Bultje
                    h->h264dsp.h264_idct_add8(dest, block_offset,
1297
                                              h->mb, uvlinesize,
1298
                                              h->non_zero_count_cache);
1299 aebb5d6d Michael Niedermayer
                }else{
1300 772225c0 Ronald S. Bultje
                    chroma_dc_dequant_idct_c(h->mb + 16*16     , h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
1301
                    chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
1302 aebb5d6d Michael Niedermayer
                    for(i=16; i<16+8; i++){
1303
                        if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
1304
                            uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
1305 881b5b80 Rafaël Carré
                            ff_svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, ff_h264_chroma_qp[s->qscale + 12] - 12, 2);
1306 aebb5d6d Michael Niedermayer
                        }
1307 e7e09b49 Loic Le Loarer
                    }
1308 4704097a Michael Niedermayer
                }
1309 0da71265 Michael Niedermayer
            }
1310
        }
1311
    }
1312 c212fb0c Michael Niedermayer
    if(h->cbp || IS_INTRA(mb_type))
1313
        s->dsp.clear_blocks(h->mb);
1314 0da71265 Michael Niedermayer
}
1315
1316
/**
1317 bd91fee3 Alexander Strange
 * Process a macroblock; this case avoids checks for expensive uncommon cases.
1318
 */
1319
static void hl_decode_mb_simple(H264Context *h){
1320
    hl_decode_mb_internal(h, 1);
1321
}
1322
1323
/**
1324
 * Process a macroblock; this handles edge cases, such as interlacing.
1325
 */
1326
static void av_noinline hl_decode_mb_complex(H264Context *h){
1327
    hl_decode_mb_internal(h, 0);
1328
}
1329
1330 903d58f6 Michael Niedermayer
void ff_h264_hl_decode_mb(H264Context *h){
1331 bd91fee3 Alexander Strange
    MpegEncContext * const s = &h->s;
1332 64514ee8 Alexander Strange
    const int mb_xy= h->mb_xy;
1333 bd91fee3 Alexander Strange
    const int mb_type= s->current_picture.mb_type[mb_xy];
1334 49fb20cb Aurelien Jacobs
    int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
1335 bd91fee3 Alexander Strange
1336
    if (is_complex)
1337
        hl_decode_mb_complex(h);
1338
    else hl_decode_mb_simple(h);
1339
}
1340
1341 0da71265 Michael Niedermayer
static int pred_weight_table(H264Context *h){
1342
    MpegEncContext * const s = &h->s;
1343
    int list, i;
1344 9f2d1b4f Loren Merritt
    int luma_def, chroma_def;
1345 115329f1 Diego Biurrun
1346 9f2d1b4f Loren Merritt
    h->use_weight= 0;
1347
    h->use_weight_chroma= 0;
1348 0da71265 Michael Niedermayer
    h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
1349 09fffe9b Jason Garrett-Glaser
    if(CHROMA)
1350
        h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
1351 9f2d1b4f Loren Merritt
    luma_def = 1<<h->luma_log2_weight_denom;
1352
    chroma_def = 1<<h->chroma_log2_weight_denom;
1353 0da71265 Michael Niedermayer
1354
    for(list=0; list<2; list++){
1355 cb99c652 Gwenole Beauchesne
        h->luma_weight_flag[list]   = 0;
1356
        h->chroma_weight_flag[list] = 0;
1357 0da71265 Michael Niedermayer
        for(i=0; i<h->ref_count[list]; i++){
1358
            int luma_weight_flag, chroma_weight_flag;
1359 115329f1 Diego Biurrun
1360 0da71265 Michael Niedermayer
            luma_weight_flag= get_bits1(&s->gb);
1361
            if(luma_weight_flag){
1362 3d9137c8 Michael Niedermayer
                h->luma_weight[i][list][0]= get_se_golomb(&s->gb);
1363
                h->luma_weight[i][list][1]= get_se_golomb(&s->gb);
1364
                if(   h->luma_weight[i][list][0] != luma_def
1365
                   || h->luma_weight[i][list][1] != 0) {
1366 9f2d1b4f Loren Merritt
                    h->use_weight= 1;
1367 cb99c652 Gwenole Beauchesne
                    h->luma_weight_flag[list]= 1;
1368
                }
1369 9f2d1b4f Loren Merritt
            }else{
1370 3d9137c8 Michael Niedermayer
                h->luma_weight[i][list][0]= luma_def;
1371
                h->luma_weight[i][list][1]= 0;
1372 0da71265 Michael Niedermayer
            }
1373
1374 0af6967e Michael Niedermayer
            if(CHROMA){
1375 fef744d4 Michael Niedermayer
                chroma_weight_flag= get_bits1(&s->gb);
1376
                if(chroma_weight_flag){
1377
                    int j;
1378
                    for(j=0; j<2; j++){
1379 3d9137c8 Michael Niedermayer
                        h->chroma_weight[i][list][j][0]= get_se_golomb(&s->gb);
1380
                        h->chroma_weight[i][list][j][1]= get_se_golomb(&s->gb);
1381
                        if(   h->chroma_weight[i][list][j][0] != chroma_def
1382
                           || h->chroma_weight[i][list][j][1] != 0) {
1383 fef744d4 Michael Niedermayer
                            h->use_weight_chroma= 1;
1384 cb99c652 Gwenole Beauchesne
                            h->chroma_weight_flag[list]= 1;
1385
                        }
1386 fef744d4 Michael Niedermayer
                    }
1387
                }else{
1388
                    int j;
1389
                    for(j=0; j<2; j++){
1390 3d9137c8 Michael Niedermayer
                        h->chroma_weight[i][list][j][0]= chroma_def;
1391
                        h->chroma_weight[i][list][j][1]= 0;
1392 fef744d4 Michael Niedermayer
                    }
1393 0da71265 Michael Niedermayer
                }
1394
            }
1395
        }
1396 9f5c1037 Michael Niedermayer
        if(h->slice_type_nos != FF_B_TYPE) break;
1397 0da71265 Michael Niedermayer
    }
1398 9f2d1b4f Loren Merritt
    h->use_weight= h->use_weight || h->use_weight_chroma;
1399 0da71265 Michael Niedermayer
    return 0;
1400
}
1401
1402 1052b76f Michael Niedermayer
/**
1403
 * Initialize implicit_weight table.
1404 6da88bd3 Diego Biurrun
 * @param field  0/1 initialize the weight for interlaced MBAFF
1405 1052b76f Michael Niedermayer
 *                -1 initializes the rest
1406
 */
1407
static void implicit_weight_table(H264Context *h, int field){
1408 9f2d1b4f Loren Merritt
    MpegEncContext * const s = &h->s;
1409 1052b76f Michael Niedermayer
    int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
1410 9f2d1b4f Loren Merritt
1411 ce09f927 Gwenole Beauchesne
    for (i = 0; i < 2; i++) {
1412
        h->luma_weight_flag[i]   = 0;
1413
        h->chroma_weight_flag[i] = 0;
1414
    }
1415
1416 1052b76f Michael Niedermayer
    if(field < 0){
1417
        cur_poc = s->current_picture_ptr->poc;
1418
    if(   h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF
1419 9f2d1b4f Loren Merritt
       && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
1420
        h->use_weight= 0;
1421
        h->use_weight_chroma= 0;
1422
        return;
1423
    }
1424 1052b76f Michael Niedermayer
        ref_start= 0;
1425
        ref_count0= h->ref_count[0];
1426
        ref_count1= h->ref_count[1];
1427
    }else{
1428
        cur_poc = s->current_picture_ptr->field_poc[field];
1429
        ref_start= 16;
1430
        ref_count0= 16+2*h->ref_count[0];
1431
        ref_count1= 16+2*h->ref_count[1];
1432
    }
1433 9f2d1b4f Loren Merritt
1434
    h->use_weight= 2;
1435
    h->use_weight_chroma= 2;
1436
    h->luma_log2_weight_denom= 5;
1437
    h->chroma_log2_weight_denom= 5;
1438
1439 1052b76f Michael Niedermayer
    for(ref0=ref_start; ref0 < ref_count0; ref0++){
1440 9f2d1b4f Loren Merritt
        int poc0 = h->ref_list[0][ref0].poc;
1441 1052b76f Michael Niedermayer
        for(ref1=ref_start; ref1 < ref_count1; ref1++){
1442 738386a5 Loren Merritt
            int poc1 = h->ref_list[1][ref1].poc;
1443 f66e4f5f Reimar Döffinger
            int td = av_clip(poc1 - poc0, -128, 127);
1444 1052b76f Michael Niedermayer
            int w= 32;
1445 9f2d1b4f Loren Merritt
            if(td){
1446 f66e4f5f Reimar Döffinger
                int tb = av_clip(cur_poc - poc0, -128, 127);
1447 c26abfa5 Diego Biurrun
                int tx = (16384 + (FFABS(td) >> 1)) / td;
1448 72f86ec0 Michael Niedermayer
                int dist_scale_factor = (tb*tx + 32) >> 8;
1449
                if(dist_scale_factor >= -64 && dist_scale_factor <= 128)
1450 1052b76f Michael Niedermayer
                    w = 64 - dist_scale_factor;
1451
            }
1452
            if(field<0){
1453
                h->implicit_weight[ref0][ref1][0]=
1454
                h->implicit_weight[ref0][ref1][1]= w;
1455
            }else{
1456
                h->implicit_weight[ref0][ref1][field]=w;
1457 72f86ec0 Michael Niedermayer
            }
1458 9f2d1b4f Loren Merritt
        }
1459
    }
1460
}
1461
1462 8fd57a66 Jeff Downs
/**
1463 5175b937 Loic Le Loarer
 * instantaneous decoder refresh.
1464 0da71265 Michael Niedermayer
 */
1465
static void idr(H264Context *h){
1466 ea6f00c4 Michael Niedermayer
    ff_h264_remove_all_refs(h);
1467 a149c1a5 Michael Niedermayer
    h->prev_frame_num= 0;
1468 80f8e035 Michael Niedermayer
    h->prev_frame_num_offset= 0;
1469
    h->prev_poc_msb=
1470
    h->prev_poc_lsb= 0;
1471 0da71265 Michael Niedermayer
}
1472
1473 7c33ad19 Loren Merritt
/* forget old pics after a seek */
1474
static void flush_dpb(AVCodecContext *avctx){
1475
    H264Context *h= avctx->priv_data;
1476
    int i;
1477 64b9d48f Alexander Strange
    for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
1478 285b570f Loren Merritt
        if(h->delayed_pic[i])
1479
            h->delayed_pic[i]->reference= 0;
1480 7c33ad19 Loren Merritt
        h->delayed_pic[i]= NULL;
1481 285b570f Loren Merritt
    }
1482 df8a7dff Michael Niedermayer
    h->outputed_poc= INT_MIN;
1483 b19d493f Haruhiko Yamagata
    h->prev_interlaced_frame = 1;
1484 7c33ad19 Loren Merritt
    idr(h);
1485 ca159196 Måns Rullgård
    if(h->s.current_picture_ptr)
1486
        h->s.current_picture_ptr->reference= 0;
1487 12d96de3 Jeff Downs
    h->s.first_field= 0;
1488 9c095463 Michael Niedermayer
    ff_h264_reset_sei(h);
1489 e240f898 Jeff Downs
    ff_mpeg_flush(avctx);
1490 7c33ad19 Loren Merritt
}
1491
1492 0da71265 Michael Niedermayer
static int init_poc(H264Context *h){
1493
    MpegEncContext * const s = &h->s;
1494
    const int max_frame_num= 1<<h->sps.log2_max_frame_num;
1495
    int field_poc[2];
1496 357282c6 Michael Niedermayer
    Picture *cur = s->current_picture_ptr;
1497 0da71265 Michael Niedermayer
1498 b78a6baa Michael Niedermayer
    h->frame_num_offset= h->prev_frame_num_offset;
1499 5710b371 Michael Niedermayer
    if(h->frame_num < h->prev_frame_num)
1500 b78a6baa Michael Niedermayer
        h->frame_num_offset += max_frame_num;
1501 0da71265 Michael Niedermayer
1502
    if(h->sps.poc_type==0){
1503
        const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
1504
1505
        if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
1506
            h->poc_msb = h->prev_poc_msb + max_poc_lsb;
1507
        else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
1508
            h->poc_msb = h->prev_poc_msb - max_poc_lsb;
1509
        else
1510
            h->poc_msb = h->prev_poc_msb;
1511
//printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
1512 115329f1 Diego Biurrun
        field_poc[0] =
1513 0da71265 Michael Niedermayer
        field_poc[1] = h->poc_msb + h->poc_lsb;
1514 115329f1 Diego Biurrun
        if(s->picture_structure == PICT_FRAME)
1515 0da71265 Michael Niedermayer
            field_poc[1] += h->delta_poc_bottom;
1516
    }else if(h->sps.poc_type==1){
1517
        int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
1518
        int i;
1519
1520
        if(h->sps.poc_cycle_length != 0)
1521
            abs_frame_num = h->frame_num_offset + h->frame_num;
1522
        else
1523
            abs_frame_num = 0;
1524
1525
        if(h->nal_ref_idc==0 && abs_frame_num > 0)
1526
            abs_frame_num--;
1527 115329f1 Diego Biurrun
1528 0da71265 Michael Niedermayer
        expected_delta_per_poc_cycle = 0;
1529
        for(i=0; i < h->sps.poc_cycle_length; i++)
1530
            expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
1531
1532
        if(abs_frame_num > 0){
1533
            int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
1534
            int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
1535
1536
            expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
1537
            for(i = 0; i <= frame_num_in_poc_cycle; i++)
1538
                expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
1539
        } else
1540
            expectedpoc = 0;
1541
1542 115329f1 Diego Biurrun
        if(h->nal_ref_idc == 0)
1543 0da71265 Michael Niedermayer
            expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
1544 115329f1 Diego Biurrun
1545 0da71265 Michael Niedermayer
        field_poc[0] = expectedpoc + h->delta_poc[0];
1546
        field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
1547
1548
        if(s->picture_structure == PICT_FRAME)
1549
            field_poc[1] += h->delta_poc[1];
1550
    }else{
1551 b78a6baa Michael Niedermayer
        int poc= 2*(h->frame_num_offset + h->frame_num);
1552 5710b371 Michael Niedermayer
1553 b78a6baa Michael Niedermayer
        if(!h->nal_ref_idc)
1554
            poc--;
1555 5710b371 Michael Niedermayer
1556 0da71265 Michael Niedermayer
        field_poc[0]= poc;
1557
        field_poc[1]= poc;
1558
    }
1559 115329f1 Diego Biurrun
1560 357282c6 Michael Niedermayer
    if(s->picture_structure != PICT_BOTTOM_FIELD)
1561 0da71265 Michael Niedermayer
        s->current_picture_ptr->field_poc[0]= field_poc[0];
1562 357282c6 Michael Niedermayer
    if(s->picture_structure != PICT_TOP_FIELD)
1563 0da71265 Michael Niedermayer
        s->current_picture_ptr->field_poc[1]= field_poc[1];
1564 357282c6 Michael Niedermayer
    cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
1565 0da71265 Michael Niedermayer
1566
    return 0;
1567
}
1568
1569 b41c1db3 Andreas Öman
1570
/**
1571
 * initialize scan tables
1572
 */
1573
static void init_scan_tables(H264Context *h){
1574
    int i;
1575 ca32f7f2 Jason Garrett-Glaser
    for(i=0; i<16; i++){
1576 b41c1db3 Andreas Öman
#define T(x) (x>>2) | ((x<<2) & 0xF)
1577 ca32f7f2 Jason Garrett-Glaser
        h->zigzag_scan[i] = T(zigzag_scan[i]);
1578
        h-> field_scan[i] = T( field_scan[i]);
1579 b41c1db3 Andreas Öman
#undef T
1580
    }
1581 ca32f7f2 Jason Garrett-Glaser
    for(i=0; i<64; i++){
1582 b41c1db3 Andreas Öman
#define T(x) (x>>3) | ((x&7)<<3)
1583 ca32f7f2 Jason Garrett-Glaser
        h->zigzag_scan8x8[i]       = T(ff_zigzag_direct[i]);
1584
        h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
1585
        h->field_scan8x8[i]        = T(field_scan8x8[i]);
1586
        h->field_scan8x8_cavlc[i]  = T(field_scan8x8_cavlc[i]);
1587 b41c1db3 Andreas Öman
#undef T
1588
    }
1589
    if(h->sps.transform_bypass){ //FIXME same ugly
1590
        h->zigzag_scan_q0          = zigzag_scan;
1591 45beb850 Stefan Gehrer
        h->zigzag_scan8x8_q0       = ff_zigzag_direct;
1592 b41c1db3 Andreas Öman
        h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
1593
        h->field_scan_q0           = field_scan;
1594
        h->field_scan8x8_q0        = field_scan8x8;
1595
        h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
1596
    }else{
1597
        h->zigzag_scan_q0          = h->zigzag_scan;
1598
        h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
1599
        h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
1600
        h->field_scan_q0           = h->field_scan;
1601
        h->field_scan8x8_q0        = h->field_scan8x8;
1602
        h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
1603
    }
1604
}
1605 afebe2f7 Andreas Öman
1606 256299d3 Michael Niedermayer
static void field_end(H264Context *h){
1607
    MpegEncContext * const s = &h->s;
1608
    AVCodecContext * const avctx= s->avctx;
1609
    s->mb_y= 0;
1610
1611
    s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
1612
    s->current_picture_ptr->pict_type= s->pict_type;
1613
1614
    if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1615
        ff_vdpau_h264_set_reference_frames(s);
1616
1617
    if(!s->dropable) {
1618 ea6f00c4 Michael Niedermayer
        ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
1619 256299d3 Michael Niedermayer
        h->prev_poc_msb= h->poc_msb;
1620
        h->prev_poc_lsb= h->poc_lsb;
1621
    }
1622
    h->prev_frame_num_offset= h->frame_num_offset;
1623
    h->prev_frame_num= h->frame_num;
1624
1625
    if (avctx->hwaccel) {
1626
        if (avctx->hwaccel->end_frame(avctx) < 0)
1627
            av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1628
    }
1629
1630
    if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1631
        ff_vdpau_h264_picture_complete(s);
1632
1633
    /*
1634
     * FIXME: Error handling code does not seem to support interlaced
1635
     * when slices span multiple rows
1636
     * The ff_er_add_slice calls don't work right for bottom
1637
     * fields; they cause massive erroneous error concealing
1638
     * Error marking covers both fields (top and bottom).
1639
     * This causes a mismatched s->error_count
1640
     * and a bad error table. Further, the error count goes to
1641
     * INT_MAX when called for bottom field, because mb_y is
1642
     * past end by one (callers fault) and resync_mb_y != 0
1643
     * causes problems for the first MB line, too.
1644
     */
1645
    if (!FIELD_PICTURE)
1646
        ff_er_frame_end(s);
1647
1648
    MPV_frame_end(s);
1649 d225a1e2 Michael Niedermayer
1650
    h->current_slice=0;
1651 256299d3 Michael Niedermayer
}
1652
1653 afebe2f7 Andreas Öman
/**
1654 49bd8e4b Måns Rullgård
 * Replicate H264 "master" context to thread contexts.
1655 afebe2f7 Andreas Öman
 */
1656
static void clone_slice(H264Context *dst, H264Context *src)
1657
{
1658
    memcpy(dst->block_offset,     src->block_offset, sizeof(dst->block_offset));
1659
    dst->s.current_picture_ptr  = src->s.current_picture_ptr;
1660
    dst->s.current_picture      = src->s.current_picture;
1661
    dst->s.linesize             = src->s.linesize;
1662
    dst->s.uvlinesize           = src->s.uvlinesize;
1663 12d96de3 Jeff Downs
    dst->s.first_field          = src->s.first_field;
1664 afebe2f7 Andreas Öman
1665
    dst->prev_poc_msb           = src->prev_poc_msb;
1666
    dst->prev_poc_lsb           = src->prev_poc_lsb;
1667
    dst->prev_frame_num_offset  = src->prev_frame_num_offset;
1668
    dst->prev_frame_num         = src->prev_frame_num;
1669
    dst->short_ref_count        = src->short_ref_count;
1670
1671
    memcpy(dst->short_ref,        src->short_ref,        sizeof(dst->short_ref));
1672
    memcpy(dst->long_ref,         src->long_ref,         sizeof(dst->long_ref));
1673
    memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));
1674
    memcpy(dst->ref_list,         src->ref_list,         sizeof(dst->ref_list));
1675 50c21814 Andreas Öman
1676
    memcpy(dst->dequant4_coeff,   src->dequant4_coeff,   sizeof(src->dequant4_coeff));
1677
    memcpy(dst->dequant8_coeff,   src->dequant8_coeff,   sizeof(src->dequant8_coeff));
1678 afebe2f7 Andreas Öman
}
1679
1680 0da71265 Michael Niedermayer
/**
1681 94e3e83f Janne Grunau
 * computes profile from profile_idc and constraint_set?_flags
1682
 *
1683
 * @param sps SPS
1684
 *
1685
 * @return profile as defined by FF_PROFILE_H264_*
1686
 */
1687
int ff_h264_get_profile(SPS *sps)
1688
{
1689
    int profile = sps->profile_idc;
1690
1691
    switch(sps->profile_idc) {
1692
    case FF_PROFILE_H264_BASELINE:
1693
        // constraint_set1_flag set to 1
1694
        profile |= (sps->constraint_set_flags & 1<<1) ? FF_PROFILE_H264_CONSTRAINED : 0;
1695
        break;
1696
    case FF_PROFILE_H264_HIGH_10:
1697
    case FF_PROFILE_H264_HIGH_422:
1698
    case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
1699
        // constraint_set3_flag set to 1
1700
        profile |= (sps->constraint_set_flags & 1<<3) ? FF_PROFILE_H264_INTRA : 0;
1701
        break;
1702
    }
1703
1704
    return profile;
1705
}
1706
1707
/**
1708 0da71265 Michael Niedermayer
 * decodes a slice header.
1709 9c852bcf Diego Biurrun
 * This will also call MPV_common_init() and frame_start() as needed.
1710 afebe2f7 Andreas Öman
 *
1711
 * @param h h264context
1712
 * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
1713
 *
1714 d9526386 Diego Biurrun
 * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
1715 0da71265 Michael Niedermayer
 */
1716 afebe2f7 Andreas Öman
static int decode_slice_header(H264Context *h, H264Context *h0){
1717 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
1718 12d96de3 Jeff Downs
    MpegEncContext * const s0 = &h0->s;
1719 88e7a4d1 Michael Niedermayer
    unsigned int first_mb_in_slice;
1720 ac658be5 Francois Oligny-Lemieux
    unsigned int pps_id;
1721 0da71265 Michael Niedermayer
    int num_ref_idx_active_override_flag;
1722 41f5c62f Michael Niedermayer
    unsigned int slice_type, tmp, i, j;
1723 0bf79634 Loic Le Loarer
    int default_ref_list_done = 0;
1724 12d96de3 Jeff Downs
    int last_pic_structure;
1725 0da71265 Michael Niedermayer
1726 2f944356 Loren Merritt
    s->dropable= h->nal_ref_idc == 0;
1727 0da71265 Michael Niedermayer
1728 cf653d08 Jeff Downs
    if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){
1729
        s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
1730
        s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
1731
    }else{
1732
        s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
1733
        s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
1734
    }
1735
1736 0da71265 Michael Niedermayer
    first_mb_in_slice= get_ue_golomb(&s->gb);
1737
1738 d225a1e2 Michael Niedermayer
    if(first_mb_in_slice == 0){ //FIXME better field boundary detection
1739
        if(h0->current_slice && FIELD_PICTURE){
1740
            field_end(h);
1741
        }
1742
1743 afebe2f7 Andreas Öman
        h0->current_slice = 0;
1744 12d96de3 Jeff Downs
        if (!s0->first_field)
1745 f6e3c460 Andreas Öman
            s->current_picture_ptr= NULL;
1746 66a4b2c1 Michael Niedermayer
    }
1747
1748 9963b332 Michael Niedermayer
    slice_type= get_ue_golomb_31(&s->gb);
1749 0bf79634 Loic Le Loarer
    if(slice_type > 9){
1750 9b879566 Michel Bardiaux
        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);
1751 5175b937 Loic Le Loarer
        return -1;
1752 0da71265 Michael Niedermayer
    }
1753 0bf79634 Loic Le Loarer
    if(slice_type > 4){
1754
        slice_type -= 5;
1755 0da71265 Michael Niedermayer
        h->slice_type_fixed=1;
1756
    }else
1757
        h->slice_type_fixed=0;
1758 115329f1 Diego Biurrun
1759 ee2a957f Diego Biurrun
    slice_type= golomb_to_pict_type[ slice_type ];
1760 9701840b Aurelien Jacobs
    if (slice_type == FF_I_TYPE
1761 afebe2f7 Andreas Öman
        || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
1762 0bf79634 Loic Le Loarer
        default_ref_list_done = 1;
1763
    }
1764
    h->slice_type= slice_type;
1765 e3e6f18f Michael Niedermayer
    h->slice_type_nos= slice_type & 3;
1766 0bf79634 Loic Le Loarer
1767 1412060e Diego Biurrun
    s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
1768 115329f1 Diego Biurrun
1769 0da71265 Michael Niedermayer
    pps_id= get_ue_golomb(&s->gb);
1770 ac658be5 Francois Oligny-Lemieux
    if(pps_id>=MAX_PPS_COUNT){
1771 9b879566 Michel Bardiaux
        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
1772 0da71265 Michael Niedermayer
        return -1;
1773
    }
1774 afebe2f7 Andreas Öman
    if(!h0->pps_buffers[pps_id]) {
1775 a0f80050 Panagiotis Issaris
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id);
1776 8b92b792 Michael Niedermayer
        return -1;
1777
    }
1778 afebe2f7 Andreas Öman
    h->pps= *h0->pps_buffers[pps_id];
1779 8b92b792 Michael Niedermayer
1780 afebe2f7 Andreas Öman
    if(!h0->sps_buffers[h->pps.sps_id]) {
1781 a0f80050 Panagiotis Issaris
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS %u referenced\n", h->pps.sps_id);
1782 8b92b792 Michael Niedermayer
        return -1;
1783
    }
1784 afebe2f7 Andreas Öman
    h->sps = *h0->sps_buffers[h->pps.sps_id];
1785 239ea04c Loren Merritt
1786 94e3e83f Janne Grunau
    s->avctx->profile = ff_h264_get_profile(&h->sps);
1787 fa37cf0d Gwenole Beauchesne
    s->avctx->level   = h->sps.level_idc;
1788 6752a3cc Gwenole Beauchesne
    s->avctx->refs    = h->sps.ref_frame_count;
1789 b08e38e8 Gwenole Beauchesne
1790 50c21814 Andreas Öman
    if(h == h0 && h->dequant_coeff_pps != pps_id){
1791 50eaa857 Guillaume Poirier
        h->dequant_coeff_pps = pps_id;
1792 239ea04c Loren Merritt
        init_dequant_tables(h);
1793
    }
1794 115329f1 Diego Biurrun
1795 0da71265 Michael Niedermayer
    s->mb_width= h->sps.mb_width;
1796 6867a90b Loic Le Loarer
    s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
1797 115329f1 Diego Biurrun
1798 bf4665ee David S. Miller
    h->b_stride=  s->mb_width*4;
1799 0da71265 Michael Niedermayer
1800 faf3dfb9 Michael Niedermayer
    s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7);
1801 0da71265 Michael Niedermayer
    if(h->sps.frame_mbs_only_flag)
1802 faf3dfb9 Michael Niedermayer
        s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7);
1803 0da71265 Michael Niedermayer
    else
1804 00d1e96b Reimar Döffinger
        s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 7);
1805 115329f1 Diego Biurrun
1806
    if (s->context_initialized
1807 5388f0b4 Janusz Krzysztofik
        && (   s->width != s->avctx->width || s->height != s->avctx->height
1808
            || av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {
1809 afebe2f7 Andreas Öman
        if(h != h0)
1810
            return -1;   // width / height changed during parallelized decoding
1811 2ed0f766 Ronald S. Bultje
        free_tables(h, 0);
1812 ff7f75e1 Michael Niedermayer
        flush_dpb(s->avctx);
1813 0da71265 Michael Niedermayer
        MPV_common_end(s);
1814
    }
1815
    if (!s->context_initialized) {
1816 afebe2f7 Andreas Öman
        if(h != h0)
1817
            return -1;  // we cant (re-)initialize context during parallel decoding
1818 f3bdc3da Reimar Döffinger
1819
        avcodec_set_dimensions(s->avctx, s->width, s->height);
1820
        s->avctx->sample_aspect_ratio= h->sps.sar;
1821 cfa5a81e Michael Niedermayer
        av_assert0(s->avctx->sample_aspect_ratio.den);
1822 f3bdc3da Reimar Döffinger
1823 c4dffe7e David Conrad
        if(h->sps.video_signal_type_present_flag){
1824
            s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
1825
            if(h->sps.colour_description_present_flag){
1826
                s->avctx->color_primaries = h->sps.color_primaries;
1827
                s->avctx->color_trc       = h->sps.color_trc;
1828
                s->avctx->colorspace      = h->sps.colorspace;
1829
            }
1830
        }
1831
1832 f3bdc3da Reimar Döffinger
        if(h->sps.timing_info_present_flag){
1833 3102d180 Michael Niedermayer
            int64_t den= h->sps.time_scale;
1834 055a6aa7 Michael Niedermayer
            if(h->x264_build < 44U)
1835 3102d180 Michael Niedermayer
                den *= 2;
1836 f3bdc3da Reimar Döffinger
            av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
1837 3102d180 Michael Niedermayer
                      h->sps.num_units_in_tick, den, 1<<30);
1838 f3bdc3da Reimar Döffinger
        }
1839 0435fb16 Baptiste Coudurier
        s->avctx->pix_fmt = s->avctx->get_format(s->avctx,
1840 9ad7dfc1 Baptiste Coudurier
                                                 s->avctx->codec->pix_fmts ?
1841
                                                 s->avctx->codec->pix_fmts :
1842 0435fb16 Baptiste Coudurier
                                                 s->avctx->color_range == AVCOL_RANGE_JPEG ?
1843
                                                 hwaccel_pixfmt_list_h264_jpeg_420 :
1844
                                                 ff_hwaccel_pixfmt_list_420);
1845 f3bdc3da Reimar Döffinger
        s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
1846
1847 0da71265 Michael Niedermayer
        if (MPV_common_init(s) < 0)
1848
            return -1;
1849 12d96de3 Jeff Downs
        s->first_field = 0;
1850 b19d493f Haruhiko Yamagata
        h->prev_interlaced_frame = 1;
1851 115329f1 Diego Biurrun
1852 b41c1db3 Andreas Öman
        init_scan_tables(h);
1853 903d58f6 Michael Niedermayer
        ff_h264_alloc_tables(h);
1854 0da71265 Michael Niedermayer
1855 afebe2f7 Andreas Öman
        for(i = 1; i < s->avctx->thread_count; i++) {
1856
            H264Context *c;
1857
            c = h->thread_context[i] = av_malloc(sizeof(H264Context));
1858 79db7ac6 Jeff Downs
            memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
1859 afebe2f7 Andreas Öman
            memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
1860 7a5c850b Alexander Strange
            c->h264dsp = h->h264dsp;
1861 afebe2f7 Andreas Öman
            c->sps = h->sps;
1862
            c->pps = h->pps;
1863
            init_scan_tables(c);
1864 145061a1 Michael Niedermayer
            clone_tables(c, h, i);
1865 afebe2f7 Andreas Öman
        }
1866
1867
        for(i = 0; i < s->avctx->thread_count; i++)
1868
            if(context_init(h->thread_context[i]) < 0)
1869
                return -1;
1870 0da71265 Michael Niedermayer
    }
1871
1872
    h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
1873
1874 5d18eaad Loren Merritt
    h->mb_mbaff = 0;
1875 6ba71fc4 Loïc Le Loarer
    h->mb_aff_frame = 0;
1876 12d96de3 Jeff Downs
    last_pic_structure = s0->picture_structure;
1877 0da71265 Michael Niedermayer
    if(h->sps.frame_mbs_only_flag){
1878
        s->picture_structure= PICT_FRAME;
1879
    }else{
1880 6ba71fc4 Loïc Le Loarer
        if(get_bits1(&s->gb)) { //field_pic_flag
1881 0da71265 Michael Niedermayer
            s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
1882 6ba71fc4 Loïc Le Loarer
        } else {
1883 0da71265 Michael Niedermayer
            s->picture_structure= PICT_FRAME;
1884 6ba71fc4 Loïc Le Loarer
            h->mb_aff_frame = h->sps.mb_aff;
1885 6867a90b Loic Le Loarer
        }
1886 0da71265 Michael Niedermayer
    }
1887 44e9dcf1 Michael Niedermayer
    h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
1888 2ddcf84b Jeff Downs
1889
    if(h0->current_slice == 0){
1890 26b86e47 Michael Niedermayer
        while(h->frame_num !=  h->prev_frame_num &&
1891
              h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
1892 4dece8c7 Jason Garrett-Glaser
            Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
1893 bb943bb8 Baptiste Coudurier
            av_log(h->s.avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num);
1894 903d58f6 Michael Niedermayer
            if (ff_h264_frame_start(h) < 0)
1895 66e6038c Reimar Döffinger
                return -1;
1896 26b86e47 Michael Niedermayer
            h->prev_frame_num++;
1897
            h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
1898
            s->current_picture_ptr->frame_num= h->prev_frame_num;
1899 3d542120 Michael Niedermayer
            ff_generate_sliding_window_mmcos(h);
1900
            ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
1901 e2983d6e Jason Garrett-Glaser
            /* Error concealment: if a ref is missing, copy the previous ref in its place.
1902
             * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
1903
             * about there being no actual duplicates.
1904
             * FIXME: this doesn't copy padding for out-of-frame motion vectors.  Given we're
1905
             * concealing a lost frame, this probably isn't noticable by comparison, but it should
1906
             * be fixed. */
1907 4dece8c7 Jason Garrett-Glaser
            if (h->short_ref_count) {
1908
                if (prev) {
1909
                    av_image_copy(h->short_ref[0]->data, h->short_ref[0]->linesize,
1910
                                  (const uint8_t**)prev->data, prev->linesize,
1911 5dd7f994 Carl Eugen Hoyos
                                  s->avctx->pix_fmt, s->mb_width*16, s->mb_height*16);
1912 4dece8c7 Jason Garrett-Glaser
                    h->short_ref[0]->poc = prev->poc+2;
1913
                }
1914
                h->short_ref[0]->frame_num = h->prev_frame_num;
1915
            }
1916 26b86e47 Michael Niedermayer
        }
1917
1918 12d96de3 Jeff Downs
        /* See if we have a decoded first field looking for a pair... */
1919
        if (s0->first_field) {
1920
            assert(s0->current_picture_ptr);
1921
            assert(s0->current_picture_ptr->data[0]);
1922
            assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);
1923
1924
            /* figure out if we have a complementary field pair */
1925
            if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {
1926
                /*
1927
                 * Previous field is unmatched. Don't display it, but let it
1928
                 * remain for reference if marked as such.
1929
                 */
1930
                s0->current_picture_ptr = NULL;
1931
                s0->first_field = FIELD_PICTURE;
1932
1933
            } else {
1934
                if (h->nal_ref_idc &&
1935
                        s0->current_picture_ptr->reference &&
1936
                        s0->current_picture_ptr->frame_num != h->frame_num) {
1937
                    /*
1938
                     * This and previous field were reference, but had
1939
                     * different frame_nums. Consider this field first in
1940
                     * pair. Throw away previous field except for reference
1941
                     * purposes.
1942
                     */
1943
                    s0->first_field = 1;
1944
                    s0->current_picture_ptr = NULL;
1945
1946
                } else {
1947
                    /* Second field in complementary pair */
1948
                    s0->first_field = 0;
1949
                }
1950
            }
1951
1952
        } else {
1953
            /* Frame or first field in a potentially complementary pair */
1954
            assert(!s0->current_picture_ptr);
1955
            s0->first_field = FIELD_PICTURE;
1956
        }
1957
1958 903d58f6 Michael Niedermayer
        if((!FIELD_PICTURE || s0->first_field) && ff_h264_frame_start(h) < 0) {
1959 12d96de3 Jeff Downs
            s0->first_field = 0;
1960 2ddcf84b Jeff Downs
            return -1;
1961 12d96de3 Jeff Downs
        }
1962 2ddcf84b Jeff Downs
    }
1963
    if(h != h0)
1964
        clone_slice(h, h0);
1965
1966
    s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup
1967
1968 88e7a4d1 Michael Niedermayer
    assert(s->mb_num == s->mb_width * s->mb_height);
1969 f3e53d9f Jeff Downs
    if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||
1970 88e7a4d1 Michael Niedermayer
       first_mb_in_slice                    >= s->mb_num){
1971
        av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
1972 6b53b87e Michael Niedermayer
        return -1;
1973
    }
1974 88e7a4d1 Michael Niedermayer
    s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
1975 f3e53d9f Jeff Downs
    s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;
1976
    if (s->picture_structure == PICT_BOTTOM_FIELD)
1977
        s->resync_mb_y = s->mb_y = s->mb_y + 1;
1978 88e7a4d1 Michael Niedermayer
    assert(s->mb_y < s->mb_height);
1979 115329f1 Diego Biurrun
1980 0da71265 Michael Niedermayer
    if(s->picture_structure==PICT_FRAME){
1981
        h->curr_pic_num=   h->frame_num;
1982
        h->max_pic_num= 1<< h->sps.log2_max_frame_num;
1983
    }else{
1984 f57e2af6 Jeff Downs
        h->curr_pic_num= 2*h->frame_num + 1;
1985 0da71265 Michael Niedermayer
        h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
1986
    }
1987 115329f1 Diego Biurrun
1988 0da71265 Michael Niedermayer
    if(h->nal_unit_type == NAL_IDR_SLICE){
1989 1df1df0b Fabrice Bellard
        get_ue_golomb(&s->gb); /* idr_pic_id */
1990 0da71265 Michael Niedermayer
    }
1991 115329f1 Diego Biurrun
1992 0da71265 Michael Niedermayer
    if(h->sps.poc_type==0){
1993
        h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
1994 115329f1 Diego Biurrun
1995 0da71265 Michael Niedermayer
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
1996
            h->delta_poc_bottom= get_se_golomb(&s->gb);
1997
        }
1998
    }
1999 115329f1 Diego Biurrun
2000 0da71265 Michael Niedermayer
    if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
2001
        h->delta_poc[0]= get_se_golomb(&s->gb);
2002 115329f1 Diego Biurrun
2003 0da71265 Michael Niedermayer
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
2004
            h->delta_poc[1]= get_se_golomb(&s->gb);
2005
    }
2006 115329f1 Diego Biurrun
2007 0da71265 Michael Niedermayer
    init_poc(h);
2008 115329f1 Diego Biurrun
2009 0da71265 Michael Niedermayer
    if(h->pps.redundant_pic_cnt_present){
2010
        h->redundant_pic_count= get_ue_golomb(&s->gb);
2011
    }
2012
2013 1412060e Diego Biurrun
    //set defaults, might be overridden a few lines later
2014 0da71265 Michael Niedermayer
    h->ref_count[0]= h->pps.ref_count[0];
2015
    h->ref_count[1]= h->pps.ref_count[1];
2016
2017 e3e6f18f Michael Niedermayer
    if(h->slice_type_nos != FF_I_TYPE){
2018 9f5c1037 Michael Niedermayer
        if(h->slice_type_nos == FF_B_TYPE){
2019 0da71265 Michael Niedermayer
            h->direct_spatial_mv_pred= get_bits1(&s->gb);
2020
        }
2021
        num_ref_idx_active_override_flag= get_bits1(&s->gb);
2022 115329f1 Diego Biurrun
2023 0da71265 Michael Niedermayer
        if(num_ref_idx_active_override_flag){
2024
            h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
2025 9f5c1037 Michael Niedermayer
            if(h->slice_type_nos==FF_B_TYPE)
2026 0da71265 Michael Niedermayer
                h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
2027
2028 187696fa Michael Niedermayer
            if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
2029 9b879566 Michel Bardiaux
                av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
2030 88e7a4d1 Michael Niedermayer
                h->ref_count[0]= h->ref_count[1]= 1;
2031 0da71265 Michael Niedermayer
                return -1;
2032
            }
2033
        }
2034 9f5c1037 Michael Niedermayer
        if(h->slice_type_nos == FF_B_TYPE)
2035 187696fa Michael Niedermayer
            h->list_count= 2;
2036
        else
2037
            h->list_count= 1;
2038
    }else
2039
        h->list_count= 0;
2040 0da71265 Michael Niedermayer
2041 0bf79634 Loic Le Loarer
    if(!default_ref_list_done){
2042 ea6f00c4 Michael Niedermayer
        ff_h264_fill_default_ref_list(h);
2043 0da71265 Michael Niedermayer
    }
2044
2045 ea6f00c4 Michael Niedermayer
    if(h->slice_type_nos!=FF_I_TYPE && ff_h264_decode_ref_pic_list_reordering(h) < 0)
2046 806bb93f Michael Niedermayer
        return -1;
2047 0da71265 Michael Niedermayer
2048 07dff5c7 Michael Niedermayer
    if(h->slice_type_nos!=FF_I_TYPE){
2049
        s->last_picture_ptr= &h->ref_list[0][0];
2050 8d2fc163 Carl Eugen Hoyos
        ff_copy_picture(&s->last_picture, s->last_picture_ptr);
2051 07dff5c7 Michael Niedermayer
    }
2052
    if(h->slice_type_nos==FF_B_TYPE){
2053
        s->next_picture_ptr= &h->ref_list[1][0];
2054 8d2fc163 Carl Eugen Hoyos
        ff_copy_picture(&s->next_picture, s->next_picture_ptr);
2055 07dff5c7 Michael Niedermayer
    }
2056
2057 932f396f Michael Niedermayer
    if(   (h->pps.weighted_pred          && h->slice_type_nos == FF_P_TYPE )
2058 9f5c1037 Michael Niedermayer
       ||  (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== FF_B_TYPE ) )
2059 0da71265 Michael Niedermayer
        pred_weight_table(h);
2060 1a29c6a0 Michael Niedermayer
    else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE){
2061 1052b76f Michael Niedermayer
        implicit_weight_table(h, -1);
2062 1a29c6a0 Michael Niedermayer
    }else {
2063 9f2d1b4f Loren Merritt
        h->use_weight = 0;
2064 cb99c652 Gwenole Beauchesne
        for (i = 0; i < 2; i++) {
2065
            h->luma_weight_flag[i]   = 0;
2066
            h->chroma_weight_flag[i] = 0;
2067
        }
2068
    }
2069 115329f1 Diego Biurrun
2070 2ddcf84b Jeff Downs
    if(h->nal_ref_idc)
2071 ea6f00c4 Michael Niedermayer
        ff_h264_decode_ref_pic_marking(h0, &s->gb);
2072 0da71265 Michael Niedermayer
2073 1052b76f Michael Niedermayer
    if(FRAME_MBAFF){
2074 ea6f00c4 Michael Niedermayer
        ff_h264_fill_mbaff_ref_list(h);
2075 5d18eaad Loren Merritt
2076 1052b76f Michael Niedermayer
        if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE){
2077
            implicit_weight_table(h, 0);
2078
            implicit_weight_table(h, 1);
2079
        }
2080
    }
2081
2082 8f56e219 Michael Niedermayer
    if(h->slice_type_nos==FF_B_TYPE && !h->direct_spatial_mv_pred)
2083 943f69a6 Michael Niedermayer
        ff_h264_direct_dist_scale_factor(h);
2084
    ff_h264_direct_ref_list_init(h);
2085 8f56e219 Michael Niedermayer
2086 e3e6f18f Michael Niedermayer
    if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){
2087 9963b332 Michael Niedermayer
        tmp = get_ue_golomb_31(&s->gb);
2088 88e7a4d1 Michael Niedermayer
        if(tmp > 2){
2089
            av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
2090
            return -1;
2091
        }
2092
        h->cabac_init_idc= tmp;
2093
    }
2094 e5017ab8 Laurent Aimar
2095
    h->last_qscale_diff = 0;
2096 88e7a4d1 Michael Niedermayer
    tmp = h->pps.init_qp + get_se_golomb(&s->gb);
2097
    if(tmp>51){
2098
        av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
2099 3ebc7e04 Michael Niedermayer
        return -1;
2100
    }
2101 88e7a4d1 Michael Niedermayer
    s->qscale= tmp;
2102 4691a77d Andreas Öman
    h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2103
    h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
2104 0da71265 Michael Niedermayer
    //FIXME qscale / qp ... stuff
2105 9701840b Aurelien Jacobs
    if(h->slice_type == FF_SP_TYPE){
2106 1df1df0b Fabrice Bellard
        get_bits1(&s->gb); /* sp_for_switch_flag */
2107 0da71265 Michael Niedermayer
    }
2108 9701840b Aurelien Jacobs
    if(h->slice_type==FF_SP_TYPE || h->slice_type == FF_SI_TYPE){
2109 1df1df0b Fabrice Bellard
        get_se_golomb(&s->gb); /* slice_qs_delta */
2110 0da71265 Michael Niedermayer
    }
2111
2112 53c05b1e Michael Niedermayer
    h->deblocking_filter = 1;
2113 0c32e19d Michael Niedermayer
    h->slice_alpha_c0_offset = 52;
2114
    h->slice_beta_offset = 52;
2115 0da71265 Michael Niedermayer
    if( h->pps.deblocking_filter_parameters_present ) {
2116 9963b332 Michael Niedermayer
        tmp= get_ue_golomb_31(&s->gb);
2117 88e7a4d1 Michael Niedermayer
        if(tmp > 2){
2118
            av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
2119
            return -1;
2120
        }
2121
        h->deblocking_filter= tmp;
2122 115329f1 Diego Biurrun
        if(h->deblocking_filter < 2)
2123 53c05b1e Michael Niedermayer
            h->deblocking_filter^= 1; // 1<->0
2124
2125
        if( h->deblocking_filter ) {
2126 0c32e19d Michael Niedermayer
            h->slice_alpha_c0_offset += get_se_golomb(&s->gb) << 1;
2127
            h->slice_beta_offset     += get_se_golomb(&s->gb) << 1;
2128
            if(   h->slice_alpha_c0_offset > 104U
2129
               || h->slice_beta_offset     > 104U){
2130
                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);
2131
                return -1;
2132
            }
2133 0da71265 Michael Niedermayer
        }
2134 980a82b7 Michael Niedermayer
    }
2135 afebe2f7 Andreas Öman
2136 61858a76 Reimar Döffinger
    if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
2137 4b30289e Michael Niedermayer
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != FF_I_TYPE)
2138 9f5c1037 Michael Niedermayer
       ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type_nos == FF_B_TYPE)
2139 61858a76 Reimar Döffinger
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
2140
        h->deblocking_filter= 0;
2141
2142 afebe2f7 Andreas Öman
    if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
2143 ec970c21 Andreas Öman
        if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
2144
            /* Cheat slightly for speed:
2145 5d81d641 Diego Biurrun
               Do not bother to deblock across slices. */
2146 ec970c21 Andreas Öman
            h->deblocking_filter = 2;
2147
        } else {
2148 7ae94d52 Andreas Öman
            h0->max_contexts = 1;
2149
            if(!h0->single_decode_warning) {
2150
                av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
2151
                h0->single_decode_warning = 1;
2152
            }
2153
            if(h != h0)
2154
                return 1; // deblocking switched inside frame
2155 ec970c21 Andreas Öman
        }
2156 afebe2f7 Andreas Öman
    }
2157 0c32e19d Michael Niedermayer
    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]);
2158 afebe2f7 Andreas Öman
2159 0da71265 Michael Niedermayer
#if 0 //FMO
2160
    if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
2161
        slice_group_change_cycle= get_bits(&s->gb, ?);
2162
#endif
2163
2164 afebe2f7 Andreas Öman
    h0->last_slice_type = slice_type;
2165
    h->slice_num = ++h0->current_slice;
2166 b735aeea Michael Niedermayer
    if(h->slice_num >= MAX_SLICES){
2167
        av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
2168
    }
2169 5175b937 Loic Le Loarer
2170 c32867b5 Michael Niedermayer
    for(j=0; j<2; j++){
2171 6d7e6b26 Michael Niedermayer
        int id_list[16];
2172 b735aeea Michael Niedermayer
        int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
2173 6d7e6b26 Michael Niedermayer
        for(i=0; i<16; i++){
2174
            id_list[i]= 60;
2175
            if(h->ref_list[j][i].data[0]){
2176
                int k;
2177
                uint8_t *base= h->ref_list[j][i].base[0];
2178
                for(k=0; k<h->short_ref_count; k++)
2179
                    if(h->short_ref[k]->base[0] == base){
2180
                        id_list[i]= k;
2181
                        break;
2182
                    }
2183
                for(k=0; k<h->long_ref_count; k++)
2184
                    if(h->long_ref[k] && h->long_ref[k]->base[0] == base){
2185
                        id_list[i]= h->short_ref_count + k;
2186
                        break;
2187
                    }
2188
            }
2189
        }
2190
2191 c32867b5 Michael Niedermayer
        ref2frm[0]=
2192
        ref2frm[1]= -1;
2193 d50cdd82 Michael Niedermayer
        for(i=0; i<16; i++)
2194 6d7e6b26 Michael Niedermayer
            ref2frm[i+2]= 4*id_list[i]
2195 c32867b5 Michael Niedermayer
                          +(h->ref_list[j][i].reference&3);
2196 d50cdd82 Michael Niedermayer
        ref2frm[18+0]=
2197
        ref2frm[18+1]= -1;
2198
        for(i=16; i<48; i++)
2199 6d7e6b26 Michael Niedermayer
            ref2frm[i+4]= 4*id_list[(i-16)>>1]
2200 d50cdd82 Michael Niedermayer
                          +(h->ref_list[j][i].reference&3);
2201 c32867b5 Michael Niedermayer
    }
2202
2203 5d18eaad Loren Merritt
    h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
2204 8a11a969 Jeff Downs
    h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
2205 5d18eaad Loren Merritt
2206 0da71265 Michael Niedermayer
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2207 49573a87 Michael Niedermayer
        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",
2208 6867a90b Loic Le Loarer
               h->slice_num,
2209
               (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
2210 115329f1 Diego Biurrun
               first_mb_in_slice,
2211 49573a87 Michael Niedermayer
               av_get_pict_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
2212 0da71265 Michael Niedermayer
               pps_id, h->frame_num,
2213
               s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
2214
               h->ref_count[0], h->ref_count[1],
2215
               s->qscale,
2216 0c32e19d Michael Niedermayer
               h->deblocking_filter, h->slice_alpha_c0_offset/2-26, h->slice_beta_offset/2-26,
2217 9f2d1b4f Loren Merritt
               h->use_weight,
2218 4806b922 Michael Niedermayer
               h->use_weight==1 && h->use_weight_chroma ? "c" : "",
2219
               h->slice_type == FF_B_TYPE ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""
2220 0da71265 Michael Niedermayer
               );
2221
    }
2222
2223
    return 0;
2224
}
2225
2226 0dc343d4 Laurent Aimar
int ff_h264_get_slice_type(const H264Context *h)
2227 75dd6938 Laurent Aimar
{
2228
    switch (h->slice_type) {
2229
    case FF_P_TYPE:  return 0;
2230
    case FF_B_TYPE:  return 1;
2231
    case FF_I_TYPE:  return 2;
2232
    case FF_SP_TYPE: return 3;
2233
    case FF_SI_TYPE: return 4;
2234
    default:         return -1;
2235
    }
2236
}
2237
2238 d02bb3ec Diego Biurrun
/**
2239
 *
2240
 * @return non zero if the loop filter can be skiped
2241
 */
2242
static int fill_filter_caches(H264Context *h, int mb_type){
2243
    MpegEncContext * const s = &h->s;
2244
    const int mb_xy= h->mb_xy;
2245
    int top_xy, left_xy[2];
2246
    int top_type, left_type[2];
2247
2248
    top_xy     = mb_xy  - (s->mb_stride << MB_FIELD);
2249
2250
    //FIXME deblocking could skip the intra and nnz parts.
2251
2252
    /* Wow, what a mess, why didn't they simplify the interlacing & intra
2253
     * stuff, I can't imagine that these complex rules are worth it. */
2254
2255
    left_xy[1] = left_xy[0] = mb_xy-1;
2256
    if(FRAME_MBAFF){
2257
        const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
2258
        const int curr_mb_field_flag     = IS_INTERLACED(mb_type);
2259
        if(s->mb_y&1){
2260
            if (left_mb_field_flag != curr_mb_field_flag) {
2261
                left_xy[0] -= s->mb_stride;
2262
            }
2263
        }else{
2264
            if(curr_mb_field_flag){
2265
                top_xy      += s->mb_stride & (((s->current_picture.mb_type[top_xy    ]>>7)&1)-1);
2266
            }
2267
            if (left_mb_field_flag != curr_mb_field_flag) {
2268
                left_xy[1] += s->mb_stride;
2269
            }
2270
        }
2271
    }
2272
2273
    h->top_mb_xy = top_xy;
2274
    h->left_mb_xy[0] = left_xy[0];
2275
    h->left_mb_xy[1] = left_xy[1];
2276
    {
2277
        //for sufficiently low qp, filtering wouldn't do anything
2278
        //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
2279
        int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
2280
        int qp = s->current_picture.qscale_table[mb_xy];
2281
        if(qp <= qp_thresh
2282
           && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
2283
           && (top_xy   < 0 || ((qp + s->current_picture.qscale_table[top_xy    ] + 1)>>1) <= qp_thresh)){
2284
            if(!FRAME_MBAFF)
2285
                return 1;
2286
            if(   (left_xy[0]< 0            || ((qp + s->current_picture.qscale_table[left_xy[1]             ] + 1)>>1) <= qp_thresh)
2287
               && (top_xy    < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy    -s->mb_stride] + 1)>>1) <= qp_thresh))
2288
                return 1;
2289
        }
2290
    }
2291
2292
    top_type     = s->current_picture.mb_type[top_xy]    ;
2293
    left_type[0] = s->current_picture.mb_type[left_xy[0]];
2294
    left_type[1] = s->current_picture.mb_type[left_xy[1]];
2295
    if(h->deblocking_filter == 2){
2296
        if(h->slice_table[top_xy     ] != h->slice_num) top_type= 0;
2297
        if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;
2298
    }else{
2299
        if(h->slice_table[top_xy     ] == 0xFFFF) top_type= 0;
2300
        if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;
2301
    }
2302
    h->top_type    = top_type    ;
2303
    h->left_type[0]= left_type[0];
2304
    h->left_type[1]= left_type[1];
2305
2306
    if(IS_INTRA(mb_type))
2307
        return 0;
2308
2309
    AV_COPY64(&h->non_zero_count_cache[0+8*1], &h->non_zero_count[mb_xy][ 0]);
2310
    AV_COPY64(&h->non_zero_count_cache[0+8*2], &h->non_zero_count[mb_xy][ 8]);
2311
    AV_COPY32(&h->non_zero_count_cache[0+8*5], &h->non_zero_count[mb_xy][16]);
2312
    AV_COPY32(&h->non_zero_count_cache[4+8*3], &h->non_zero_count[mb_xy][20]);
2313
    AV_COPY64(&h->non_zero_count_cache[0+8*4], &h->non_zero_count[mb_xy][24]);
2314
2315
    h->cbp= h->cbp_table[mb_xy];
2316
2317
    {
2318
        int list;
2319
        for(list=0; list<h->list_count; list++){
2320
            int8_t *ref;
2321
            int y, b_stride;
2322
            int16_t (*mv_dst)[2];
2323
            int16_t (*mv_src)[2];
2324
2325
            if(!USES_LIST(mb_type, list)){
2326
                fill_rectangle(  h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
2327
                AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2328
                AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2329
                AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2330
                AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2331
                continue;
2332
            }
2333
2334
            ref = &s->current_picture.ref_index[list][4*mb_xy];
2335
            {
2336
                int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2337
                AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2338
                AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2339
                ref += 2;
2340
                AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2341
                AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2342
            }
2343
2344
            b_stride = h->b_stride;
2345
            mv_dst   = &h->mv_cache[list][scan8[0]];
2346
            mv_src   = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
2347
            for(y=0; y<4; y++){
2348
                AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
2349
            }
2350
2351
        }
2352
    }
2353
2354
2355
/*
2356
0 . T T. T T T T
2357
1 L . .L . . . .
2358
2 L . .L . . . .
2359
3 . T TL . . . .
2360
4 L . .L . . . .
2361
5 L . .. . . . .
2362
*/
2363
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
2364
    if(top_type){
2365
        AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]);
2366
    }
2367
2368
    if(left_type[0]){
2369
        h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][7+0*8];
2370
        h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][7+1*8];
2371
        h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][7+2*8];
2372
        h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][7+3*8];
2373
    }
2374
2375
    // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
2376
    if(!CABAC && h->pps.transform_8x8_mode){
2377
        if(IS_8x8DCT(top_type)){
2378
            h->non_zero_count_cache[4+8*0]=
2379
            h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4;
2380
            h->non_zero_count_cache[6+8*0]=
2381
            h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8;
2382
        }
2383
        if(IS_8x8DCT(left_type[0])){
2384
            h->non_zero_count_cache[3+8*1]=
2385
            h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF
2386
        }
2387
        if(IS_8x8DCT(left_type[1])){
2388
            h->non_zero_count_cache[3+8*3]=
2389
            h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF
2390
        }
2391
2392
        if(IS_8x8DCT(mb_type)){
2393
            h->non_zero_count_cache[scan8[0   ]]= h->non_zero_count_cache[scan8[1   ]]=
2394
            h->non_zero_count_cache[scan8[2   ]]= h->non_zero_count_cache[scan8[3   ]]= h->cbp & 1;
2395
2396
            h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
2397
            h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
2398
2399
            h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
2400
            h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
2401
2402
            h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
2403
            h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
2404
        }
2405
    }
2406
2407
    if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
2408
        int list;
2409
        for(list=0; list<h->list_count; list++){
2410
            if(USES_LIST(top_type, list)){
2411
                const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
2412
                const int b8_xy= 4*top_xy + 2;
2413
                int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2414
                AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
2415
                h->ref_cache[list][scan8[0] + 0 - 1*8]=
2416
                h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
2417
                h->ref_cache[list][scan8[0] + 2 - 1*8]=
2418
                h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
2419
            }else{
2420
                AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
2421
                AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2422
            }
2423
2424
            if(!IS_INTERLACED(mb_type^left_type[0])){
2425
                if(USES_LIST(left_type[0], list)){
2426
                    const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
2427
                    const int b8_xy= 4*left_xy[0] + 1;
2428
                    int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2429
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);
2430
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);
2431
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);
2432
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);
2433
                    h->ref_cache[list][scan8[0] - 1 + 0 ]=
2434
                    h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];
2435
                    h->ref_cache[list][scan8[0] - 1 +16 ]=
2436
                    h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];
2437
                }else{
2438
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);
2439
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);
2440
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);
2441
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);
2442
                    h->ref_cache[list][scan8[0] - 1 + 0  ]=
2443
                    h->ref_cache[list][scan8[0] - 1 + 8  ]=
2444
                    h->ref_cache[list][scan8[0] - 1 + 16 ]=
2445
                    h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
2446
                }
2447
            }
2448
        }
2449
    }
2450
2451
    return 0;
2452
}
2453
2454 c988f975 Michael Niedermayer
static void loop_filter(H264Context *h){
2455
    MpegEncContext * const s = &h->s;
2456
    uint8_t  *dest_y, *dest_cb, *dest_cr;
2457
    int linesize, uvlinesize, mb_x, mb_y;
2458
    const int end_mb_y= s->mb_y + FRAME_MBAFF;
2459
    const int old_slice_type= h->slice_type;
2460
2461
    if(h->deblocking_filter) {
2462
        for(mb_x= 0; mb_x<s->mb_width; mb_x++){
2463
            for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){
2464 78998bf2 Alexander Strange
                int mb_xy, mb_type;
2465 c988f975 Michael Niedermayer
                mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;
2466
                h->slice_num= h->slice_table[mb_xy];
2467
                mb_type= s->current_picture.mb_type[mb_xy];
2468
                h->list_count= h->list_counts[mb_xy];
2469
2470
                if(FRAME_MBAFF)
2471
                    h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2472
2473
                s->mb_x= mb_x;
2474
                s->mb_y= mb_y;
2475
                dest_y  = s->current_picture.data[0] + (mb_x + mb_y * s->linesize  ) * 16;
2476
                dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
2477
                dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
2478
                    //FIXME simplify above
2479
2480
                if (MB_FIELD) {
2481
                    linesize   = h->mb_linesize   = s->linesize * 2;
2482
                    uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
2483
                    if(mb_y&1){ //FIXME move out of this function?
2484
                        dest_y -= s->linesize*15;
2485
                        dest_cb-= s->uvlinesize*7;
2486
                        dest_cr-= s->uvlinesize*7;
2487
                    }
2488
                } else {
2489
                    linesize   = h->mb_linesize   = s->linesize;
2490
                    uvlinesize = h->mb_uvlinesize = s->uvlinesize;
2491
                }
2492 77d40dce Michael Niedermayer
                backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
2493 aaa995d7 Michael Niedermayer
                if(fill_filter_caches(h, mb_type))
2494 44a5e7b6 Michael Niedermayer
                    continue;
2495 c988f975 Michael Niedermayer
                h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
2496
                h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
2497
2498 77d40dce Michael Niedermayer
                if (FRAME_MBAFF) {
2499 c988f975 Michael Niedermayer
                    ff_h264_filter_mb     (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2500
                } else {
2501
                    ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2502
                }
2503
            }
2504
        }
2505
    }
2506
    h->slice_type= old_slice_type;
2507
    s->mb_x= 0;
2508
    s->mb_y= end_mb_y - FRAME_MBAFF;
2509 f4b8b825 Michael Niedermayer
    h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2510
    h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
2511 c988f975 Michael Niedermayer
}
2512
2513 69a28f3e Michael Niedermayer
static void predict_field_decoding_flag(H264Context *h){
2514
    MpegEncContext * const s = &h->s;
2515
    const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
2516
    int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
2517
                ? s->current_picture.mb_type[mb_xy-1]
2518
                : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
2519
                ? s->current_picture.mb_type[mb_xy-s->mb_stride]
2520
                : 0;
2521
    h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2522
}
2523
2524 3a84713a Roman Shaposhnik
static int decode_slice(struct AVCodecContext *avctx, void *arg){
2525
    H264Context *h = *(void**)arg;
2526 0da71265 Michael Niedermayer
    MpegEncContext * const s = &h->s;
2527
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
2528
2529
    s->mb_skip_run= -1;
2530
2531 89db0bae Michael Niedermayer
    h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
2532 5317c95b Måns Rullgård
                    (CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY));
2533 89db0bae Michael Niedermayer
2534 e5017ab8 Laurent Aimar
    if( h->pps.cabac ) {
2535
        /* realign */
2536
        align_get_bits( &s->gb );
2537
2538
        /* init cabac */
2539 d61c4e73 Michael Niedermayer
        ff_init_cabac_states( &h->cabac);
2540 e5017ab8 Laurent Aimar
        ff_init_cabac_decoder( &h->cabac,
2541
                               s->gb.buffer + get_bits_count(&s->gb)/8,
2542 6e44ba15 Ronald S. Bultje
                               (get_bits_left(&s->gb) + 7)/8);
2543 cc51b282 Michael Niedermayer
2544
        ff_h264_init_cabac_states(h);
2545 95c26348 Michael Niedermayer
2546 e5017ab8 Laurent Aimar
        for(;;){
2547 851ded89 Michael Niedermayer
//START_TIMER
2548 cc51b282 Michael Niedermayer
            int ret = ff_h264_decode_mb_cabac(h);
2549 6867a90b Loic Le Loarer
            int eos;
2550 851ded89 Michael Niedermayer
//STOP_TIMER("decode_mb_cabac")
2551 0da71265 Michael Niedermayer
2552 903d58f6 Michael Niedermayer
            if(ret>=0) ff_h264_hl_decode_mb(h);
2553 0da71265 Michael Niedermayer
2554 5d18eaad Loren Merritt
            if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
2555 e5017ab8 Laurent Aimar
                s->mb_y++;
2556
2557 cc51b282 Michael Niedermayer
                ret = ff_h264_decode_mb_cabac(h);
2558 e5017ab8 Laurent Aimar
2559 903d58f6 Michael Niedermayer
                if(ret>=0) ff_h264_hl_decode_mb(h);
2560 e5017ab8 Laurent Aimar
                s->mb_y--;
2561
            }
2562 6867a90b Loic Le Loarer
            eos = get_cabac_terminate( &h->cabac );
2563 e5017ab8 Laurent Aimar
2564 3566042a Michael Niedermayer
            if((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2){
2565
                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);
2566
                return 0;
2567
            }
2568 5659b509 Michael Niedermayer
            if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
2569 706da4af Måns Rullgård
                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);
2570 e5017ab8 Laurent Aimar
                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);
2571
                return -1;
2572
            }
2573
2574
            if( ++s->mb_x >= s->mb_width ) {
2575
                s->mb_x = 0;
2576 c988f975 Michael Niedermayer
                loop_filter(h);
2577 e5017ab8 Laurent Aimar
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
2578 5175b937 Loic Le Loarer
                ++s->mb_y;
2579 f3e53d9f Jeff Downs
                if(FIELD_OR_MBAFF_PICTURE) {
2580 6867a90b Loic Le Loarer
                    ++s->mb_y;
2581 69cc3183 Michael Niedermayer
                    if(FRAME_MBAFF && s->mb_y < s->mb_height)
2582
                        predict_field_decoding_flag(h);
2583 6867a90b Loic Le Loarer
                }
2584 0da71265 Michael Niedermayer
            }
2585
2586 e5017ab8 Laurent Aimar
            if( eos || s->mb_y >= s->mb_height ) {
2587 a9c9a240 Michel Bardiaux
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
2588 e5017ab8 Laurent Aimar
                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);
2589 0da71265 Michael Niedermayer
                return 0;
2590 e5017ab8 Laurent Aimar
            }
2591
        }
2592
2593
    } else {
2594
        for(;;){
2595 e1e94902 Michael Niedermayer
            int ret = ff_h264_decode_mb_cavlc(h);
2596 e5017ab8 Laurent Aimar
2597 903d58f6 Michael Niedermayer
            if(ret>=0) ff_h264_hl_decode_mb(h);
2598 e5017ab8 Laurent Aimar
2599 5d18eaad Loren Merritt
            if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
2600 e5017ab8 Laurent Aimar
                s->mb_y++;
2601 e1e94902 Michael Niedermayer
                ret = ff_h264_decode_mb_cavlc(h);
2602 e5017ab8 Laurent Aimar
2603 903d58f6 Michael Niedermayer
                if(ret>=0) ff_h264_hl_decode_mb(h);
2604 e5017ab8 Laurent Aimar
                s->mb_y--;
2605
            }
2606
2607
            if(ret<0){
2608
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
2609 0da71265 Michael Niedermayer
                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);
2610
2611
                return -1;
2612
            }
2613 e5017ab8 Laurent Aimar
2614
            if(++s->mb_x >= s->mb_width){
2615
                s->mb_x=0;
2616 c988f975 Michael Niedermayer
                loop_filter(h);
2617 e5017ab8 Laurent Aimar
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
2618 6867a90b Loic Le Loarer
                ++s->mb_y;
2619 f3e53d9f Jeff Downs
                if(FIELD_OR_MBAFF_PICTURE) {
2620 6867a90b Loic Le Loarer
                    ++s->mb_y;
2621 69cc3183 Michael Niedermayer
                    if(FRAME_MBAFF && s->mb_y < s->mb_height)
2622
                        predict_field_decoding_flag(h);
2623 6867a90b Loic Le Loarer
                }
2624
                if(s->mb_y >= s->mb_height){
2625