← Back to branch summary

~noskcaj/ubuntu/saucy/libav/merge0.8.7-1

« back to all changes in this revision

Viewing changes to .pc/post-0.7.1/0036-h264-fix-PCM-intra-coded-blocks-in-monochrome-case.patch/libavcodec/h264.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2011-10-01 00:22:07 UTC
  • mfrom: (1.3.8 sid)
  • Revision ID: package-import@ubuntu.com-20111001002207-tnxz39i0rwr5ufy9
Tags: 4:0.7.2-1ubuntu1
* Merge from debian, remaining changes:
  - don't build against libfaad, libdirac, librtmp and libopenjpeg,
    lame, xvid, x264  (all in universe)
  - not installing into multiarch directories
* This new upstream release has basically merged in all 70 patches that
  are present in 4:0.7.1-7ubuntu2, plus some additional, similarily
  focused ones.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/post-0.7.1/0036-h264-fix-PCM-intra-coded-blocks-in-monochrome-case.patch/libavcodec/h264.c
1
 
/*
2
 
 * H.26L/H.264/AVC/JVT/14496-10/... decoder
3
 
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4
 
 *
5
 
 * This file is part of Libav.
6
 
 *
7
 
 * Libav is free software; you can redistribute it and/or
8
 
 * modify it under the terms of the GNU Lesser General Public
9
 
 * License as published by the Free Software Foundation; either
10
 
 * version 2.1 of the License, or (at your option) any later version.
11
 
 *
12
 
 * Libav is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 
 * Lesser General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with Libav; if not, write to the Free Software
19
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 
 */
21
 
 
22
 
/**
23
 
 * @file
24
 
 * H.264 / AVC / MPEG4 part10 codec.
25
 
 * @author Michael Niedermayer <michaelni@gmx.at>
26
 
 */
27
 
 
28
 
#include "libavutil/imgutils.h"
29
 
#include "internal.h"
30
 
#include "dsputil.h"
31
 
#include "avcodec.h"
32
 
#include "mpegvideo.h"
33
 
#include "h264.h"
34
 
#include "h264data.h"
35
 
#include "h264_mvpred.h"
36
 
#include "golomb.h"
37
 
#include "mathops.h"
38
 
#include "rectangle.h"
39
 
#include "thread.h"
40
 
#include "vdpau_internal.h"
41
 
#include "libavutil/avassert.h"
42
 
 
43
 
#include "cabac.h"
44
 
 
45
 
//#undef NDEBUG
46
 
#include <assert.h>
47
 
 
48
 
static const uint8_t rem6[QP_MAX_NUM+1]={
49
 
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, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
50
 
};
51
 
 
52
 
static const uint8_t div6[QP_MAX_NUM+1]={
53
 
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, 8, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,
54
 
};
55
 
 
56
 
static const enum PixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = {
57
 
    PIX_FMT_DXVA2_VLD,
58
 
    PIX_FMT_VAAPI_VLD,
59
 
    PIX_FMT_YUVJ420P,
60
 
    PIX_FMT_NONE
61
 
};
62
 
 
63
 
void ff_h264_write_back_intra_pred_mode(H264Context *h){
64
 
    int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
65
 
 
66
 
    AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
67
 
    mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
68
 
    mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
69
 
    mode[6]= h->intra4x4_pred_mode_cache[7+8*1];
70
 
}
71
 
 
72
 
/**
73
 
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
74
 
 */
75
 
int ff_h264_check_intra4x4_pred_mode(H264Context *h){
76
 
    MpegEncContext * const s = &h->s;
77
 
    static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
78
 
    static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
79
 
    int i;
80
 
 
81
 
    if(!(h->top_samples_available&0x8000)){
82
 
        for(i=0; i<4; i++){
83
 
            int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
84
 
            if(status<0){
85
 
                av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
86
 
                return -1;
87
 
            } else if(status){
88
 
                h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
89
 
            }
90
 
        }
91
 
    }
92
 
 
93
 
    if((h->left_samples_available&0x8888)!=0x8888){
94
 
        static const int mask[4]={0x8000,0x2000,0x80,0x20};
95
 
        for(i=0; i<4; i++){
96
 
            if(!(h->left_samples_available&mask[i])){
97
 
                int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
98
 
                if(status<0){
99
 
                    av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
100
 
                    return -1;
101
 
                } else if(status){
102
 
                    h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
103
 
                }
104
 
            }
105
 
        }
106
 
    }
107
 
 
108
 
    return 0;
109
 
} //FIXME cleanup like ff_h264_check_intra_pred_mode
110
 
 
111
 
/**
112
 
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
113
 
 */
114
 
int ff_h264_check_intra_pred_mode(H264Context *h, int mode){
115
 
    MpegEncContext * const s = &h->s;
116
 
    static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
117
 
    static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
118
 
 
119
 
    if(mode > 6U) {
120
 
        av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y);
121
 
        return -1;
122
 
    }
123
 
 
124
 
    if(!(h->top_samples_available&0x8000)){
125
 
        mode= top[ mode ];
126
 
        if(mode<0){
127
 
            av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
128
 
            return -1;
129
 
        }
130
 
    }
131
 
 
132
 
    if((h->left_samples_available&0x8080) != 0x8080){
133
 
        mode= left[ mode ];
134
 
        if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
135
 
            mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
136
 
        }
137
 
        if(mode<0){
138
 
            av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
139
 
            return -1;
140
 
        }
141
 
    }
142
 
 
143
 
    return mode;
144
 
}
145
 
 
146
 
const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
147
 
    int i, si, di;
148
 
    uint8_t *dst;
149
 
    int bufidx;
150
 
 
151
 
//    src[0]&0x80;                //forbidden bit
152
 
    h->nal_ref_idc= src[0]>>5;
153
 
    h->nal_unit_type= src[0]&0x1F;
154
 
 
155
 
    src++; length--;
156
 
 
157
 
#if HAVE_FAST_UNALIGNED
158
 
# if HAVE_FAST_64BIT
159
 
#   define RS 7
160
 
    for(i=0; i+1<length; i+=9){
161
 
        if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))
162
 
# else
163
 
#   define RS 3
164
 
    for(i=0; i+1<length; i+=5){
165
 
        if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U))
166
 
# endif
167
 
            continue;
168
 
        if(i>0 && !src[i]) i--;
169
 
        while(src[i]) i++;
170
 
#else
171
 
#   define RS 0
172
 
    for(i=0; i+1<length; i+=2){
173
 
        if(src[i]) continue;
174
 
        if(i>0 && src[i-1]==0) i--;
175
 
#endif
176
 
        if(i+2<length && src[i+1]==0 && src[i+2]<=3){
177
 
            if(src[i+2]!=3){
178
 
                /* startcode, so we must be past the end */
179
 
                length=i;
180
 
            }
181
 
            break;
182
 
        }
183
 
        i-= RS;
184
 
    }
185
 
 
186
 
    if(i>=length-1){ //no escaped 0
187
 
        *dst_length= length;
188
 
        *consumed= length+1; //+1 for the header
189
 
        return src;
190
 
    }
191
 
 
192
 
    bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
193
 
    av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
194
 
    dst= h->rbsp_buffer[bufidx];
195
 
 
196
 
    if (dst == NULL){
197
 
        return NULL;
198
 
    }
199
 
 
200
 
//printf("decoding esc\n");
201
 
    memcpy(dst, src, i);
202
 
    si=di=i;
203
 
    while(si+2<length){
204
 
        //remove escapes (very rare 1:2^22)
205
 
        if(src[si+2]>3){
206
 
            dst[di++]= src[si++];
207
 
            dst[di++]= src[si++];
208
 
        }else if(src[si]==0 && src[si+1]==0){
209
 
            if(src[si+2]==3){ //escape
210
 
                dst[di++]= 0;
211
 
                dst[di++]= 0;
212
 
                si+=3;
213
 
                continue;
214
 
            }else //next start code
215
 
                goto nsc;
216
 
        }
217
 
 
218
 
        dst[di++]= src[si++];
219
 
    }
220
 
    while(si<length)
221
 
        dst[di++]= src[si++];
222
 
nsc:
223
 
 
224
 
    memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
225
 
 
226
 
    *dst_length= di;
227
 
    *consumed= si + 1;//+1 for the header
228
 
//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
229
 
    return dst;
230
 
}
231
 
 
232
 
/**
233
 
 * Identify the exact end of the bitstream
234
 
 * @return the length of the trailing, or 0 if damaged
235
 
 */
236
 
static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){
237
 
    int v= *src;
238
 
    int r;
239
 
 
240
 
    tprintf(h->s.avctx, "rbsp trailing %X\n", v);
241
 
 
242
 
    for(r=1; r<9; r++){
243
 
        if(v&1) return r;
244
 
        v>>=1;
245
 
    }
246
 
    return 0;
247
 
}
248
 
 
249
 
static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height,
250
 
                                 int y_offset, int list){
251
 
    int raw_my= h->mv_cache[list][ scan8[n] ][1];
252
 
    int filter_height= (raw_my&3) ? 2 : 0;
253
 
    int full_my= (raw_my>>2) + y_offset;
254
 
    int top = full_my - filter_height, bottom = full_my + height + filter_height;
255
 
 
256
 
    return FFMAX(abs(top), bottom);
257
 
}
258
 
 
259
 
static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,
260
 
                               int y_offset, int list0, int list1, int *nrefs){
261
 
    MpegEncContext * const s = &h->s;
262
 
    int my;
263
 
 
264
 
    y_offset += 16*(s->mb_y >> MB_FIELD);
265
 
 
266
 
    if(list0){
267
 
        int ref_n = h->ref_cache[0][ scan8[n] ];
268
 
        Picture *ref= &h->ref_list[0][ref_n];
269
 
 
270
 
        // Error resilience puts the current picture in the ref list.
271
 
        // Don't try to wait on these as it will cause a deadlock.
272
 
        // Fields can wait on each other, though.
273
 
        if(ref->thread_opaque != s->current_picture.thread_opaque ||
274
 
           (ref->reference&3) != s->picture_structure) {
275
 
            my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);
276
 
            if (refs[0][ref_n] < 0) nrefs[0] += 1;
277
 
            refs[0][ref_n] = FFMAX(refs[0][ref_n], my);
278
 
        }
279
 
    }
280
 
 
281
 
    if(list1){
282
 
        int ref_n = h->ref_cache[1][ scan8[n] ];
283
 
        Picture *ref= &h->ref_list[1][ref_n];
284
 
 
285
 
        if(ref->thread_opaque != s->current_picture.thread_opaque ||
286
 
           (ref->reference&3) != s->picture_structure) {
287
 
            my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);
288
 
            if (refs[1][ref_n] < 0) nrefs[1] += 1;
289
 
            refs[1][ref_n] = FFMAX(refs[1][ref_n], my);
290
 
        }
291
 
    }
292
 
}
293
 
 
294
 
/**
295
 
 * Wait until all reference frames are available for MC operations.
296
 
 *
297
 
 * @param h the H264 context
298
 
 */
299
 
static void await_references(H264Context *h){
300
 
    MpegEncContext * const s = &h->s;
301
 
    const int mb_xy= h->mb_xy;
302
 
    const int mb_type= s->current_picture.mb_type[mb_xy];
303
 
    int refs[2][48];
304
 
    int nrefs[2] = {0};
305
 
    int ref, list;
306
 
 
307
 
    memset(refs, -1, sizeof(refs));
308
 
 
309
 
    if(IS_16X16(mb_type)){
310
 
        get_lowest_part_y(h, refs, 0, 16, 0,
311
 
                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
312
 
    }else if(IS_16X8(mb_type)){
313
 
        get_lowest_part_y(h, refs, 0, 8, 0,
314
 
                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
315
 
        get_lowest_part_y(h, refs, 8, 8, 8,
316
 
                  IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
317
 
    }else if(IS_8X16(mb_type)){
318
 
        get_lowest_part_y(h, refs, 0, 16, 0,
319
 
                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
320
 
        get_lowest_part_y(h, refs, 4, 16, 0,
321
 
                  IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
322
 
    }else{
323
 
        int i;
324
 
 
325
 
        assert(IS_8X8(mb_type));
326
 
 
327
 
        for(i=0; i<4; i++){
328
 
            const int sub_mb_type= h->sub_mb_type[i];
329
 
            const int n= 4*i;
330
 
            int y_offset= (i&2)<<2;
331
 
 
332
 
            if(IS_SUB_8X8(sub_mb_type)){
333
 
                get_lowest_part_y(h, refs, n  , 8, y_offset,
334
 
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
335
 
            }else if(IS_SUB_8X4(sub_mb_type)){
336
 
                get_lowest_part_y(h, refs, n  , 4, y_offset,
337
 
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
338
 
                get_lowest_part_y(h, refs, n+2, 4, y_offset+4,
339
 
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
340
 
            }else if(IS_SUB_4X8(sub_mb_type)){
341
 
                get_lowest_part_y(h, refs, n  , 8, y_offset,
342
 
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
343
 
                get_lowest_part_y(h, refs, n+1, 8, y_offset,
344
 
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
345
 
            }else{
346
 
                int j;
347
 
                assert(IS_SUB_4X4(sub_mb_type));
348
 
                for(j=0; j<4; j++){
349
 
                    int sub_y_offset= y_offset + 2*(j&2);
350
 
                    get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,
351
 
                              IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
352
 
                }
353
 
            }
354
 
        }
355
 
    }
356
 
 
357
 
    for(list=h->list_count-1; list>=0; list--){
358
 
        for(ref=0; ref<48 && nrefs[list]; ref++){
359
 
            int row = refs[list][ref];
360
 
            if(row >= 0){
361
 
                Picture *ref_pic = &h->ref_list[list][ref];
362
 
                int ref_field = ref_pic->reference - 1;
363
 
                int ref_field_picture = ref_pic->field_picture;
364
 
                int pic_height = 16*s->mb_height >> ref_field_picture;
365
 
 
366
 
                row <<= MB_MBAFF;
367
 
                nrefs[list]--;
368
 
 
369
 
                if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields
370
 
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);
371
 
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);
372
 
                }else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame
373
 
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);
374
 
                }else if(FIELD_PICTURE){
375
 
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);
376
 
                }else{
377
 
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);
378
 
                }
379
 
            }
380
 
        }
381
 
    }
382
 
}
383
 
 
384
 
#if 0
385
 
/**
386
 
 * DCT transforms the 16 dc values.
387
 
 * @param qp quantization parameter ??? FIXME
388
 
 */
389
 
static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
390
 
//    const int qmul= dequant_coeff[qp][0];
391
 
    int i;
392
 
    int temp[16]; //FIXME check if this is a good idea
393
 
    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
394
 
    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
395
 
 
396
 
    for(i=0; i<4; i++){
397
 
        const int offset= y_offset[i];
398
 
        const int z0= block[offset+stride*0] + block[offset+stride*4];
399
 
        const int z1= block[offset+stride*0] - block[offset+stride*4];
400
 
        const int z2= block[offset+stride*1] - block[offset+stride*5];
401
 
        const int z3= block[offset+stride*1] + block[offset+stride*5];
402
 
 
403
 
        temp[4*i+0]= z0+z3;
404
 
        temp[4*i+1]= z1+z2;
405
 
        temp[4*i+2]= z1-z2;
406
 
        temp[4*i+3]= z0-z3;
407
 
    }
408
 
 
409
 
    for(i=0; i<4; i++){
410
 
        const int offset= x_offset[i];
411
 
        const int z0= temp[4*0+i] + temp[4*2+i];
412
 
        const int z1= temp[4*0+i] - temp[4*2+i];
413
 
        const int z2= temp[4*1+i] - temp[4*3+i];
414
 
        const int z3= temp[4*1+i] + temp[4*3+i];
415
 
 
416
 
        block[stride*0 +offset]= (z0 + z3)>>1;
417
 
        block[stride*2 +offset]= (z1 + z2)>>1;
418
 
        block[stride*8 +offset]= (z1 - z2)>>1;
419
 
        block[stride*10+offset]= (z0 - z3)>>1;
420
 
    }
421
 
}
422
 
#endif
423
 
 
424
 
#undef xStride
425
 
#undef stride
426
 
 
427
 
#if 0
428
 
static void chroma_dc_dct_c(DCTELEM *block){
429
 
    const int stride= 16*2;
430
 
    const int xStride= 16;
431
 
    int a,b,c,d,e;
432
 
 
433
 
    a= block[stride*0 + xStride*0];
434
 
    b= block[stride*0 + xStride*1];
435
 
    c= block[stride*1 + xStride*0];
436
 
    d= block[stride*1 + xStride*1];
437
 
 
438
 
    e= a-b;
439
 
    a= a+b;
440
 
    b= c-d;
441
 
    c= c+d;
442
 
 
443
 
    block[stride*0 + xStride*0]= (a+c);
444
 
    block[stride*0 + xStride*1]= (e+b);
445
 
    block[stride*1 + xStride*0]= (a-c);
446
 
    block[stride*1 + xStride*1]= (e-b);
447
 
}
448
 
#endif
449
 
 
450
 
static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
451
 
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
452
 
                           int src_x_offset, int src_y_offset,
453
 
                           qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op,
454
 
                           int pixel_shift, int chroma444){
455
 
    MpegEncContext * const s = &h->s;
456
 
    const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
457
 
    int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
458
 
    const int luma_xy= (mx&3) + ((my&3)<<2);
459
 
    int offset = ((mx>>2) << pixel_shift) + (my>>2)*h->mb_linesize;
460
 
    uint8_t * src_y = pic->data[0] + offset;
461
 
    uint8_t * src_cb, * src_cr;
462
 
    int extra_width= h->emu_edge_width;
463
 
    int extra_height= h->emu_edge_height;
464
 
    int emu=0;
465
 
    const int full_mx= mx>>2;
466
 
    const int full_my= my>>2;
467
 
    const int pic_width  = 16*s->mb_width;
468
 
    const int pic_height = 16*s->mb_height >> MB_FIELD;
469
 
 
470
 
    if(mx&7) extra_width -= 3;
471
 
    if(my&7) extra_height -= 3;
472
 
 
473
 
    if(   full_mx < 0-extra_width
474
 
       || full_my < 0-extra_height
475
 
       || full_mx + 16/*FIXME*/ > pic_width + extra_width
476
 
       || full_my + 16/*FIXME*/ > pic_height + extra_height){
477
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_y - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
478
 
            src_y= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;
479
 
        emu=1;
480
 
    }
481
 
 
482
 
    qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
483
 
    if(!square){
484
 
        qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
485
 
    }
486
 
 
487
 
    if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
488
 
 
489
 
    if(chroma444){
490
 
        src_cb = pic->data[1] + offset;
491
 
        if(emu){
492
 
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize,
493
 
                                    16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
494
 
            src_cb= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;
495
 
        }
496
 
        qpix_op[luma_xy](dest_cb, src_cb, h->mb_linesize); //FIXME try variable height perhaps?
497
 
        if(!square){
498
 
            qpix_op[luma_xy](dest_cb + delta, src_cb + delta, h->mb_linesize);
499
 
        }
500
 
 
501
 
        src_cr = pic->data[2] + offset;
502
 
        if(emu){
503
 
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cr - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize,
504
 
                                    16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
505
 
            src_cr= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;
506
 
        }
507
 
        qpix_op[luma_xy](dest_cr, src_cr, h->mb_linesize); //FIXME try variable height perhaps?
508
 
        if(!square){
509
 
            qpix_op[luma_xy](dest_cr + delta, src_cr + delta, h->mb_linesize);
510
 
        }
511
 
        return;
512
 
    }
513
 
 
514
 
    if(MB_FIELD){
515
 
        // chroma offset when predicting from a field of opposite parity
516
 
        my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
517
 
        emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
518
 
    }
519
 
    src_cb= pic->data[1] + ((mx>>3) << pixel_shift) + (my>>3)*h->mb_uvlinesize;
520
 
    src_cr= pic->data[2] + ((mx>>3) << pixel_shift) + (my>>3)*h->mb_uvlinesize;
521
 
 
522
 
    if(emu){
523
 
        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);
524
 
            src_cb= s->edge_emu_buffer;
525
 
    }
526
 
    chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
527
 
 
528
 
    if(emu){
529
 
        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);
530
 
            src_cr= s->edge_emu_buffer;
531
 
    }
532
 
    chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
533
 
}
534
 
 
535
 
static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
536
 
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
537
 
                           int x_offset, int y_offset,
538
 
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
539
 
                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
540
 
                           int list0, int list1, int pixel_shift, int chroma444){
541
 
    MpegEncContext * const s = &h->s;
542
 
    qpel_mc_func *qpix_op=  qpix_put;
543
 
    h264_chroma_mc_func chroma_op= chroma_put;
544
 
 
545
 
    dest_y  += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
546
 
    if(chroma444){
547
 
        dest_cb += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
548
 
        dest_cr += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
549
 
    }else{
550
 
        dest_cb += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
551
 
        dest_cr += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
552
 
    }
553
 
    x_offset += 8*s->mb_x;
554
 
    y_offset += 8*(s->mb_y >> MB_FIELD);
555
 
 
556
 
    if(list0){
557
 
        Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
558
 
        mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
559
 
                           dest_y, dest_cb, dest_cr, x_offset, y_offset,
560
 
                           qpix_op, chroma_op, pixel_shift, chroma444);
561
 
 
562
 
        qpix_op=  qpix_avg;
563
 
        chroma_op= chroma_avg;
564
 
    }
565
 
 
566
 
    if(list1){
567
 
        Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
568
 
        mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
569
 
                           dest_y, dest_cb, dest_cr, x_offset, y_offset,
570
 
                           qpix_op, chroma_op, pixel_shift, chroma444);
571
 
    }
572
 
}
573
 
 
574
 
static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
575
 
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
576
 
                           int x_offset, int y_offset,
577
 
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
578
 
                           h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
579
 
                           h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
580
 
                           int list0, int list1, int pixel_shift, int chroma444){
581
 
    MpegEncContext * const s = &h->s;
582
 
 
583
 
    dest_y += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
584
 
    if(chroma444){
585
 
        chroma_weight_avg = luma_weight_avg;
586
 
        chroma_weight_op = luma_weight_op;
587
 
        dest_cb += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
588
 
        dest_cr += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
589
 
    }else{
590
 
        dest_cb += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
591
 
        dest_cr += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
592
 
    }
593
 
    x_offset += 8*s->mb_x;
594
 
    y_offset += 8*(s->mb_y >> MB_FIELD);
595
 
 
596
 
    if(list0 && list1){
597
 
        /* don't optimize for luma-only case, since B-frames usually
598
 
         * use implicit weights => chroma too. */
599
 
        uint8_t *tmp_cb = s->obmc_scratchpad;
600
 
        uint8_t *tmp_cr = s->obmc_scratchpad + (16 << pixel_shift);
601
 
        uint8_t *tmp_y  = s->obmc_scratchpad + 16*h->mb_uvlinesize;
602
 
        int refn0 = h->ref_cache[0][ scan8[n] ];
603
 
        int refn1 = h->ref_cache[1][ scan8[n] ];
604
 
 
605
 
        mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
606
 
                    dest_y, dest_cb, dest_cr,
607
 
                    x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma444);
608
 
        mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
609
 
                    tmp_y, tmp_cb, tmp_cr,
610
 
                    x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma444);
611
 
 
612
 
        if(h->use_weight == 2){
613
 
            int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1];
614
 
            int weight1 = 64 - weight0;
615
 
            luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);
616
 
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
617
 
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
618
 
        }else{
619
 
            luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
620
 
                            h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0],
621
 
                            h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]);
622
 
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
623
 
                            h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0],
624
 
                            h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]);
625
 
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
626
 
                            h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0],
627
 
                            h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]);
628
 
        }
629
 
    }else{
630
 
        int list = list1 ? 1 : 0;
631
 
        int refn = h->ref_cache[list][ scan8[n] ];
632
 
        Picture *ref= &h->ref_list[list][refn];
633
 
        mc_dir_part(h, ref, n, square, chroma_height, delta, list,
634
 
                    dest_y, dest_cb, dest_cr, x_offset, y_offset,
635
 
                    qpix_put, chroma_put, pixel_shift, chroma444);
636
 
 
637
 
        luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
638
 
                       h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]);
639
 
        if(h->use_weight_chroma){
640
 
            chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
641
 
                             h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]);
642
 
            chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
643
 
                             h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]);
644
 
        }
645
 
    }
646
 
}
647
 
 
648
 
static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
649
 
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
650
 
                           int x_offset, int y_offset,
651
 
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
652
 
                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
653
 
                           h264_weight_func *weight_op, h264_biweight_func *weight_avg,
654
 
                           int list0, int list1, int pixel_shift, int chroma444){
655
 
    if((h->use_weight==2 && list0 && list1
656
 
        && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32))
657
 
       || h->use_weight==1)
658
 
        mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
659
 
                         x_offset, y_offset, qpix_put, chroma_put,
660
 
                         weight_op[0], weight_op[3], weight_avg[0],
661
 
                         weight_avg[3], list0, list1, pixel_shift, chroma444);
662
 
    else
663
 
        mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
664
 
                    x_offset, y_offset, qpix_put, chroma_put, qpix_avg,
665
 
                    chroma_avg, list0, list1, pixel_shift, chroma444);
666
 
}
667
 
 
668
 
static inline void prefetch_motion(H264Context *h, int list, int pixel_shift, int chroma444){
669
 
    /* fetch pixels for estimated mv 4 macroblocks ahead
670
 
     * optimized for 64byte cache lines */
671
 
    MpegEncContext * const s = &h->s;
672
 
    const int refn = h->ref_cache[list][scan8[0]];
673
 
    if(refn >= 0){
674
 
        const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
675
 
        const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
676
 
        uint8_t **src= h->ref_list[list][refn].data;
677
 
        int off= (mx << pixel_shift) + (my + (s->mb_x&3)*4)*h->mb_linesize + (64 << pixel_shift);
678
 
        s->dsp.prefetch(src[0]+off, s->linesize, 4);
679
 
        if(chroma444){
680
 
            s->dsp.prefetch(src[1]+off, s->linesize, 4);
681
 
            s->dsp.prefetch(src[2]+off, s->linesize, 4);
682
 
        }else{
683
 
            off= ((mx>>1) << pixel_shift) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + (64 << pixel_shift);
684
 
            s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
685
 
        }
686
 
    }
687
 
}
688
 
 
689
 
static av_always_inline void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
690
 
                      qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
691
 
                      qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
692
 
                      h264_weight_func *weight_op, h264_biweight_func *weight_avg,
693
 
                      int pixel_shift, int chroma444){
694
 
    MpegEncContext * const s = &h->s;
695
 
    const int mb_xy= h->mb_xy;
696
 
    const int mb_type= s->current_picture.mb_type[mb_xy];
697
 
 
698
 
    assert(IS_INTER(mb_type));
699
 
 
700
 
    if(HAVE_PTHREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
701
 
        await_references(h);
702
 
    prefetch_motion(h, 0, pixel_shift, chroma444);
703
 
 
704
 
    if(IS_16X16(mb_type)){
705
 
        mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
706
 
                qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
707
 
                weight_op, weight_avg,
708
 
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),
709
 
                pixel_shift, chroma444);
710
 
    }else if(IS_16X8(mb_type)){
711
 
        mc_part(h, 0, 0, 4, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 0,
712
 
                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
713
 
                &weight_op[1], &weight_avg[1],
714
 
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),
715
 
                pixel_shift, chroma444);
716
 
        mc_part(h, 8, 0, 4, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 4,
717
 
                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
718
 
                &weight_op[1], &weight_avg[1],
719
 
                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),
720
 
                pixel_shift, chroma444);
721
 
    }else if(IS_8X16(mb_type)){
722
 
        mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
723
 
                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
724
 
                &weight_op[2], &weight_avg[2],
725
 
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),
726
 
                pixel_shift, chroma444);
727
 
        mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
728
 
                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
729
 
                &weight_op[2], &weight_avg[2],
730
 
                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),
731
 
                pixel_shift, chroma444);
732
 
    }else{
733
 
        int i;
734
 
 
735
 
        assert(IS_8X8(mb_type));
736
 
 
737
 
        for(i=0; i<4; i++){
738
 
            const int sub_mb_type= h->sub_mb_type[i];
739
 
            const int n= 4*i;
740
 
            int x_offset= (i&1)<<2;
741
 
            int y_offset= (i&2)<<1;
742
 
 
743
 
            if(IS_SUB_8X8(sub_mb_type)){
744
 
                mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
745
 
                    qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
746
 
                    &weight_op[3], &weight_avg[3],
747
 
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
748
 
                    pixel_shift, chroma444);
749
 
            }else if(IS_SUB_8X4(sub_mb_type)){
750
 
                mc_part(h, n  , 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset,
751
 
                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
752
 
                    &weight_op[4], &weight_avg[4],
753
 
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
754
 
                    pixel_shift, chroma444);
755
 
                mc_part(h, n+2, 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
756
 
                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
757
 
                    &weight_op[4], &weight_avg[4],
758
 
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
759
 
                    pixel_shift, chroma444);
760
 
            }else if(IS_SUB_4X8(sub_mb_type)){
761
 
                mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
762
 
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
763
 
                    &weight_op[5], &weight_avg[5],
764
 
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
765
 
                    pixel_shift, chroma444);
766
 
                mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
767
 
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
768
 
                    &weight_op[5], &weight_avg[5],
769
 
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
770
 
                    pixel_shift, chroma444);
771
 
            }else{
772
 
                int j;
773
 
                assert(IS_SUB_4X4(sub_mb_type));
774
 
                for(j=0; j<4; j++){
775
 
                    int sub_x_offset= x_offset + 2*(j&1);
776
 
                    int sub_y_offset= y_offset +   (j&2);
777
 
                    mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
778
 
                        qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
779
 
                        &weight_op[6], &weight_avg[6],
780
 
                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
781
 
                        pixel_shift, chroma444);
782
 
                }
783
 
            }
784
 
        }
785
 
    }
786
 
 
787
 
    prefetch_motion(h, 1, pixel_shift, chroma444);
788
 
}
789
 
 
790
 
#define hl_motion_fn(sh, bits) \
791
 
static av_always_inline void hl_motion_ ## bits(H264Context *h, \
792
 
                                       uint8_t *dest_y, \
793
 
                                       uint8_t *dest_cb, uint8_t *dest_cr, \
794
 
                                       qpel_mc_func (*qpix_put)[16], \
795
 
                                       h264_chroma_mc_func (*chroma_put), \
796
 
                                       qpel_mc_func (*qpix_avg)[16], \
797
 
                                       h264_chroma_mc_func (*chroma_avg), \
798
 
                                       h264_weight_func *weight_op, \
799
 
                                       h264_biweight_func *weight_avg, \
800
 
                                       int chroma444) \
801
 
{ \
802
 
    hl_motion(h, dest_y, dest_cb, dest_cr, qpix_put, chroma_put, \
803
 
              qpix_avg, chroma_avg, weight_op, weight_avg, sh, chroma444); \
804
 
}
805
 
hl_motion_fn(0, 8);
806
 
hl_motion_fn(1, 16);
807
 
 
808
 
static void free_tables(H264Context *h, int free_rbsp){
809
 
    int i;
810
 
    H264Context *hx;
811
 
 
812
 
    av_freep(&h->intra4x4_pred_mode);
813
 
    av_freep(&h->chroma_pred_mode_table);
814
 
    av_freep(&h->cbp_table);
815
 
    av_freep(&h->mvd_table[0]);
816
 
    av_freep(&h->mvd_table[1]);
817
 
    av_freep(&h->direct_table);
818
 
    av_freep(&h->non_zero_count);
819
 
    av_freep(&h->slice_table_base);
820
 
    h->slice_table= NULL;
821
 
    av_freep(&h->list_counts);
822
 
 
823
 
    av_freep(&h->mb2b_xy);
824
 
    av_freep(&h->mb2br_xy);
825
 
 
826
 
    for(i = 0; i < MAX_THREADS; i++) {
827
 
        hx = h->thread_context[i];
828
 
        if(!hx) continue;
829
 
        av_freep(&hx->top_borders[1]);
830
 
        av_freep(&hx->top_borders[0]);
831
 
        av_freep(&hx->s.obmc_scratchpad);
832
 
        if (free_rbsp){
833
 
            av_freep(&hx->rbsp_buffer[1]);
834
 
            av_freep(&hx->rbsp_buffer[0]);
835
 
            hx->rbsp_buffer_size[0] = 0;
836
 
            hx->rbsp_buffer_size[1] = 0;
837
 
        }
838
 
        if (i) av_freep(&h->thread_context[i]);
839
 
    }
840
 
}
841
 
 
842
 
static void init_dequant8_coeff_table(H264Context *h){
843
 
    int i,j,q,x;
844
 
    const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
845
 
 
846
 
    for(i=0; i<6; i++ ){
847
 
        h->dequant8_coeff[i] = h->dequant8_buffer[i];
848
 
        for(j=0; j<i; j++){
849
 
            if(!memcmp(h->pps.scaling_matrix8[j], h->pps.scaling_matrix8[i], 64*sizeof(uint8_t))){
850
 
                h->dequant8_coeff[i] = h->dequant8_buffer[j];
851
 
                break;
852
 
            }
853
 
        }
854
 
        if(j<i)
855
 
            continue;
856
 
 
857
 
        for(q=0; q<max_qp+1; q++){
858
 
            int shift = div6[q];
859
 
            int idx = rem6[q];
860
 
            for(x=0; x<64; x++)
861
 
                h->dequant8_coeff[i][q][(x>>3)|((x&7)<<3)] =
862
 
                    ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
863
 
                    h->pps.scaling_matrix8[i][x]) << shift;
864
 
        }
865
 
    }
866
 
}
867
 
 
868
 
static void init_dequant4_coeff_table(H264Context *h){
869
 
    int i,j,q,x;
870
 
    const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
871
 
    for(i=0; i<6; i++ ){
872
 
        h->dequant4_coeff[i] = h->dequant4_buffer[i];
873
 
        for(j=0; j<i; j++){
874
 
            if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
875
 
                h->dequant4_coeff[i] = h->dequant4_buffer[j];
876
 
                break;
877
 
            }
878
 
        }
879
 
        if(j<i)
880
 
            continue;
881
 
 
882
 
        for(q=0; q<max_qp+1; q++){
883
 
            int shift = div6[q] + 2;
884
 
            int idx = rem6[q];
885
 
            for(x=0; x<16; x++)
886
 
                h->dequant4_coeff[i][q][(x>>2)|((x<<2)&0xF)] =
887
 
                    ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
888
 
                    h->pps.scaling_matrix4[i][x]) << shift;
889
 
        }
890
 
    }
891
 
}
892
 
 
893
 
static void init_dequant_tables(H264Context *h){
894
 
    int i,x;
895
 
    init_dequant4_coeff_table(h);
896
 
    if(h->pps.transform_8x8_mode)
897
 
        init_dequant8_coeff_table(h);
898
 
    if(h->sps.transform_bypass){
899
 
        for(i=0; i<6; i++)
900
 
            for(x=0; x<16; x++)
901
 
                h->dequant4_coeff[i][0][x] = 1<<6;
902
 
        if(h->pps.transform_8x8_mode)
903
 
            for(i=0; i<6; i++)
904
 
                for(x=0; x<64; x++)
905
 
                    h->dequant8_coeff[i][0][x] = 1<<6;
906
 
    }
907
 
}
908
 
 
909
 
 
910
 
int ff_h264_alloc_tables(H264Context *h){
911
 
    MpegEncContext * const s = &h->s;
912
 
    const int big_mb_num= s->mb_stride * (s->mb_height+1);
913
 
    const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;
914
 
    int x,y;
915
 
 
916
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8  * sizeof(uint8_t), fail)
917
 
 
918
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count    , big_mb_num * 48 * sizeof(uint8_t), fail)
919
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail)
920
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail)
921
 
 
922
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail)
923
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail);
924
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail);
925
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail);
926
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail)
927
 
 
928
 
    memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(*h->slice_table_base));
929
 
    h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
930
 
 
931
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy  , big_mb_num * sizeof(uint32_t), fail);
932
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail);
933
 
    for(y=0; y<s->mb_height; y++){
934
 
        for(x=0; x<s->mb_width; x++){
935
 
            const int mb_xy= x + y*s->mb_stride;
936
 
            const int b_xy = 4*x + 4*y*h->b_stride;
937
 
 
938
 
            h->mb2b_xy [mb_xy]= b_xy;
939
 
            h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride)));
940
 
        }
941
 
    }
942
 
 
943
 
    s->obmc_scratchpad = NULL;
944
 
 
945
 
    if(!h->dequant4_coeff[0])
946
 
        init_dequant_tables(h);
947
 
 
948
 
    return 0;
949
 
fail:
950
 
    free_tables(h, 1);
951
 
    return -1;
952
 
}
953
 
 
954
 
/**
955
 
 * Mimic alloc_tables(), but for every context thread.
956
 
 */
957
 
static void clone_tables(H264Context *dst, H264Context *src, int i){
958
 
    MpegEncContext * const s = &src->s;
959
 
    dst->intra4x4_pred_mode       = src->intra4x4_pred_mode + i*8*2*s->mb_stride;
960
 
    dst->non_zero_count           = src->non_zero_count;
961
 
    dst->slice_table              = src->slice_table;
962
 
    dst->cbp_table                = src->cbp_table;
963
 
    dst->mb2b_xy                  = src->mb2b_xy;
964
 
    dst->mb2br_xy                 = src->mb2br_xy;
965
 
    dst->chroma_pred_mode_table   = src->chroma_pred_mode_table;
966
 
    dst->mvd_table[0]             = src->mvd_table[0] + i*8*2*s->mb_stride;
967
 
    dst->mvd_table[1]             = src->mvd_table[1] + i*8*2*s->mb_stride;
968
 
    dst->direct_table             = src->direct_table;
969
 
    dst->list_counts              = src->list_counts;
970
 
 
971
 
    dst->s.obmc_scratchpad = NULL;
972
 
    ff_h264_pred_init(&dst->hpc, src->s.codec_id, src->sps.bit_depth_luma);
973
 
}
974
 
 
975
 
/**
976
 
 * Init context
977
 
 * Allocate buffers which are not shared amongst multiple threads.
978
 
 */
979
 
static int context_init(H264Context *h){
980
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * 16*3 * sizeof(uint8_t)*2, fail)
981
 
    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * 16*3 * sizeof(uint8_t)*2, fail)
982
 
 
983
 
    h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =
984
 
    h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;
985
 
 
986
 
    return 0;
987
 
fail:
988
 
    return -1; // free_tables will clean up for us
989
 
}
990
 
 
991
 
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size);
992
 
 
993
 
static av_cold void common_init(H264Context *h){
994
 
    MpegEncContext * const s = &h->s;
995
 
 
996
 
    s->width = s->avctx->width;
997
 
    s->height = s->avctx->height;
998
 
    s->codec_id= s->avctx->codec->id;
999
 
 
1000
 
    ff_h264dsp_init(&h->h264dsp, 8);
1001
 
    ff_h264_pred_init(&h->hpc, s->codec_id, 8);
1002
 
 
1003
 
    h->dequant_coeff_pps= -1;
1004
 
    s->unrestricted_mv=1;
1005
 
    s->decode=1; //FIXME
1006
 
 
1007
 
    dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
1008
 
 
1009
 
    memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
1010
 
    memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
1011
 
}
1012
 
 
1013
 
int ff_h264_decode_extradata(H264Context *h)
1014
 
{
1015
 
    AVCodecContext *avctx = h->s.avctx;
1016
 
 
1017
 
    if(avctx->extradata[0] == 1){
1018
 
        int i, cnt, nalsize;
1019
 
        unsigned char *p = avctx->extradata;
1020
 
 
1021
 
        h->is_avc = 1;
1022
 
 
1023
 
        if(avctx->extradata_size < 7) {
1024
 
            av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
1025
 
            return -1;
1026
 
        }
1027
 
        /* sps and pps in the avcC always have length coded with 2 bytes,
1028
 
           so put a fake nal_length_size = 2 while parsing them */
1029
 
        h->nal_length_size = 2;
1030
 
        // Decode sps from avcC
1031
 
        cnt = *(p+5) & 0x1f; // Number of sps
1032
 
        p += 6;
1033
 
        for (i = 0; i < cnt; i++) {
1034
 
            nalsize = AV_RB16(p) + 2;
1035
 
            if(decode_nal_units(h, p, nalsize) < 0) {
1036
 
                av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
1037
 
                return -1;
1038
 
            }
1039
 
            p += nalsize;
1040
 
        }
1041
 
        // Decode pps from avcC
1042
 
        cnt = *(p++); // Number of pps
1043
 
        for (i = 0; i < cnt; i++) {
1044
 
            nalsize = AV_RB16(p) + 2;
1045
 
            if (decode_nal_units(h, p, nalsize) < 0) {
1046
 
                av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
1047
 
                return -1;
1048
 
            }
1049
 
            p += nalsize;
1050
 
        }
1051
 
        // Now store right nal length size, that will be use to parse all other nals
1052
 
        h->nal_length_size = (avctx->extradata[4] & 0x03) + 1;
1053
 
    } else {
1054
 
        h->is_avc = 0;
1055
 
        if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)
1056
 
            return -1;
1057
 
    }
1058
 
    return 0;
1059
 
}
1060
 
 
1061
 
av_cold int ff_h264_decode_init(AVCodecContext *avctx){
1062
 
    H264Context *h= avctx->priv_data;
1063
 
    MpegEncContext * const s = &h->s;
1064
 
 
1065
 
    MPV_decode_defaults(s);
1066
 
 
1067
 
    s->avctx = avctx;
1068
 
    common_init(h);
1069
 
 
1070
 
    s->out_format = FMT_H264;
1071
 
    s->workaround_bugs= avctx->workaround_bugs;
1072
 
 
1073
 
    // set defaults
1074
 
//    s->decode_mb= ff_h263_decode_mb;
1075
 
    s->quarter_sample = 1;
1076
 
    if(!avctx->has_b_frames)
1077
 
    s->low_delay= 1;
1078
 
 
1079
 
    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
1080
 
 
1081
 
    ff_h264_decode_init_vlc();
1082
 
 
1083
 
    h->pixel_shift = 0;
1084
 
    h->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;
1085
 
 
1086
 
    h->thread_context[0] = h;
1087
 
    h->outputed_poc = h->next_outputed_poc = INT_MIN;
1088
 
    h->prev_poc_msb= 1<<16;
1089
 
    h->x264_build = -1;
1090
 
    ff_h264_reset_sei(h);
1091
 
    if(avctx->codec_id == CODEC_ID_H264){
1092
 
        if(avctx->ticks_per_frame == 1){
1093
 
            s->avctx->time_base.den *=2;
1094
 
        }
1095
 
        avctx->ticks_per_frame = 2;
1096
 
    }
1097
 
 
1098
 
    if(avctx->extradata_size > 0 && avctx->extradata &&
1099
 
        ff_h264_decode_extradata(h))
1100
 
        return -1;
1101
 
 
1102
 
    if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){
1103
 
        s->avctx->has_b_frames = h->sps.num_reorder_frames;
1104
 
        s->low_delay = 0;
1105
 
    }
1106
 
 
1107
 
    return 0;
1108
 
}
1109
 
 
1110
 
#define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))
1111
 
static void copy_picture_range(Picture **to, Picture **from, int count, MpegEncContext *new_base, MpegEncContext *old_base)
1112
 
{
1113
 
    int i;
1114
 
 
1115
 
    for (i=0; i<count; i++){
1116
 
        assert((IN_RANGE(from[i], old_base, sizeof(*old_base)) ||
1117
 
                IN_RANGE(from[i], old_base->picture, sizeof(Picture) * old_base->picture_count) ||
1118
 
                !from[i]));
1119
 
        to[i] = REBASE_PICTURE(from[i], new_base, old_base);
1120
 
    }
1121
 
}
1122
 
 
1123
 
static void copy_parameter_set(void **to, void **from, int count, int size)
1124
 
{
1125
 
    int i;
1126
 
 
1127
 
    for (i=0; i<count; i++){
1128
 
        if (to[i] && !from[i]) av_freep(&to[i]);
1129
 
        else if (from[i] && !to[i]) to[i] = av_malloc(size);
1130
 
 
1131
 
        if (from[i]) memcpy(to[i], from[i], size);
1132
 
    }
1133
 
}
1134
 
 
1135
 
static int decode_init_thread_copy(AVCodecContext *avctx){
1136
 
    H264Context *h= avctx->priv_data;
1137
 
 
1138
 
    if (!avctx->is_copy) return 0;
1139
 
    memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
1140
 
    memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
1141
 
 
1142
 
    return 0;
1143
 
}
1144
 
 
1145
 
#define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)
1146
 
static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src){
1147
 
    H264Context *h= dst->priv_data, *h1= src->priv_data;
1148
 
    MpegEncContext * const s = &h->s, * const s1 = &h1->s;
1149
 
    int inited = s->context_initialized, err;
1150
 
    int i;
1151
 
 
1152
 
    if(dst == src || !s1->context_initialized) return 0;
1153
 
 
1154
 
    err = ff_mpeg_update_thread_context(dst, src);
1155
 
    if(err) return err;
1156
 
 
1157
 
    //FIXME handle width/height changing
1158
 
    if(!inited){
1159
 
        for(i = 0; i < MAX_SPS_COUNT; i++)
1160
 
            av_freep(h->sps_buffers + i);
1161
 
 
1162
 
        for(i = 0; i < MAX_PPS_COUNT; i++)
1163
 
            av_freep(h->pps_buffers + i);
1164
 
 
1165
 
        memcpy(&h->s + 1, &h1->s + 1, sizeof(H264Context) - sizeof(MpegEncContext)); //copy all fields after MpegEnc
1166
 
        memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
1167
 
        memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
1168
 
        if (ff_h264_alloc_tables(h) < 0) {
1169
 
            av_log(dst, AV_LOG_ERROR, "Could not allocate memory for h264\n");
1170
 
            return AVERROR(ENOMEM);
1171
 
        }
1172
 
        context_init(h);
1173
 
 
1174
 
        for(i=0; i<2; i++){
1175
 
            h->rbsp_buffer[i] = NULL;
1176
 
            h->rbsp_buffer_size[i] = 0;
1177
 
        }
1178
 
 
1179
 
        h->thread_context[0] = h;
1180
 
 
1181
 
        // frame_start may not be called for the next thread (if it's decoding a bottom field)
1182
 
        // so this has to be allocated here
1183
 
        h->s.obmc_scratchpad = av_malloc(16*6*s->linesize);
1184
 
 
1185
 
        s->dsp.clear_blocks(h->mb);
1186
 
        s->dsp.clear_blocks(h->mb+(24*16<<h->pixel_shift));
1187
 
    }
1188
 
 
1189
 
    //extradata/NAL handling
1190
 
    h->is_avc          = h1->is_avc;
1191
 
 
1192
 
    //SPS/PPS
1193
 
    copy_parameter_set((void**)h->sps_buffers, (void**)h1->sps_buffers, MAX_SPS_COUNT, sizeof(SPS));
1194
 
    h->sps             = h1->sps;
1195
 
    copy_parameter_set((void**)h->pps_buffers, (void**)h1->pps_buffers, MAX_PPS_COUNT, sizeof(PPS));
1196
 
    h->pps             = h1->pps;
1197
 
 
1198
 
    //Dequantization matrices
1199
 
    //FIXME these are big - can they be only copied when PPS changes?
1200
 
    copy_fields(h, h1, dequant4_buffer, dequant4_coeff);
1201
 
 
1202
 
    for(i=0; i<6; i++)
1203
 
        h->dequant4_coeff[i] = h->dequant4_buffer[0] + (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);
1204
 
 
1205
 
    for(i=0; i<6; i++)
1206
 
        h->dequant8_coeff[i] = h->dequant8_buffer[0] + (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);
1207
 
 
1208
 
    h->dequant_coeff_pps = h1->dequant_coeff_pps;
1209
 
 
1210
 
    //POC timing
1211
 
    copy_fields(h, h1, poc_lsb, redundant_pic_count);
1212
 
 
1213
 
    //reference lists
1214
 
    copy_fields(h, h1, ref_count, list_count);
1215
 
    copy_fields(h, h1, ref_list,  intra_gb);
1216
 
    copy_fields(h, h1, short_ref, cabac_init_idc);
1217
 
 
1218
 
    copy_picture_range(h->short_ref,   h1->short_ref,   32, s, s1);
1219
 
    copy_picture_range(h->long_ref,    h1->long_ref,    32, s, s1);
1220
 
    copy_picture_range(h->delayed_pic, h1->delayed_pic, MAX_DELAYED_PIC_COUNT+2, s, s1);
1221
 
 
1222
 
    h->last_slice_type = h1->last_slice_type;
1223
 
 
1224
 
    if(!s->current_picture_ptr) return 0;
1225
 
 
1226
 
    if(!s->dropable) {
1227
 
        ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
1228
 
        h->prev_poc_msb     = h->poc_msb;
1229
 
        h->prev_poc_lsb     = h->poc_lsb;
1230
 
    }
1231
 
    h->prev_frame_num_offset= h->frame_num_offset;
1232
 
    h->prev_frame_num       = h->frame_num;
1233
 
    h->outputed_poc         = h->next_outputed_poc;
1234
 
 
1235
 
    return 0;
1236
 
}
1237
 
 
1238
 
int ff_h264_frame_start(H264Context *h){
1239
 
    MpegEncContext * const s = &h->s;
1240
 
    int i;
1241
 
    const int pixel_shift = h->pixel_shift;
1242
 
    int thread_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;
1243
 
 
1244
 
    if(MPV_frame_start(s, s->avctx) < 0)
1245
 
        return -1;
1246
 
    ff_er_frame_start(s);
1247
 
    /*
1248
 
     * MPV_frame_start uses pict_type to derive key_frame.
1249
 
     * This is incorrect for H.264; IDR markings must be used.
1250
 
     * Zero here; IDR markings per slice in frame or fields are ORed in later.
1251
 
     * See decode_nal_units().
1252
 
     */
1253
 
    s->current_picture_ptr->key_frame= 0;
1254
 
    s->current_picture_ptr->mmco_reset= 0;
1255
 
 
1256
 
    assert(s->linesize && s->uvlinesize);
1257
 
 
1258
 
    for(i=0; i<16; i++){
1259
 
        h->block_offset[i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
1260
 
        h->block_offset[48+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
1261
 
    }
1262
 
    for(i=0; i<16; i++){
1263
 
        h->block_offset[16+i]=
1264
 
        h->block_offset[32+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
1265
 
        h->block_offset[48+16+i]=
1266
 
        h->block_offset[48+32+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
1267
 
    }
1268
 
 
1269
 
    /* can't be in alloc_tables because linesize isn't known there.
1270
 
     * FIXME: redo bipred weight to not require extra buffer? */
1271
 
    for(i = 0; i < thread_count; i++)
1272
 
        if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)
1273
 
            h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*6*s->linesize);
1274
 
 
1275
 
    /* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/
1276
 
    memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
1277
 
 
1278
 
//    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
1279
 
 
1280
 
    // We mark the current picture as non-reference after allocating it, so
1281
 
    // that if we break out due to an error it can be released automatically
1282
 
    // in the next MPV_frame_start().
1283
 
    // SVQ3 as well as most other codecs have only last/next/current and thus
1284
 
    // get released even with set reference, besides SVQ3 and others do not
1285
 
    // mark frames as reference later "naturally".
1286
 
    if(s->codec_id != CODEC_ID_SVQ3)
1287
 
        s->current_picture_ptr->reference= 0;
1288
 
 
1289
 
    s->current_picture_ptr->field_poc[0]=
1290
 
    s->current_picture_ptr->field_poc[1]= INT_MAX;
1291
 
 
1292
 
    h->next_output_pic = NULL;
1293
 
 
1294
 
    assert(s->current_picture_ptr->long_ref==0);
1295
 
 
1296
 
    return 0;
1297
 
}
1298
 
 
1299
 
/**
1300
 
  * Run setup operations that must be run after slice header decoding.
1301
 
  * This includes finding the next displayed frame.
1302
 
  *
1303
 
  * @param h h264 master context
1304
 
  * @param setup_finished enough NALs have been read that we can call
1305
 
  * ff_thread_finish_setup()
1306
 
  */
1307
 
static void decode_postinit(H264Context *h, int setup_finished){
1308
 
    MpegEncContext * const s = &h->s;
1309
 
    Picture *out = s->current_picture_ptr;
1310
 
    Picture *cur = s->current_picture_ptr;
1311
 
    int i, pics, out_of_order, out_idx;
1312
 
 
1313
 
    s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
1314
 
    s->current_picture_ptr->pict_type= s->pict_type;
1315
 
 
1316
 
    if (h->next_output_pic) return;
1317
 
 
1318
 
    if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
1319
 
        //FIXME: if we have two PAFF fields in one packet, we can't start the next thread here.
1320
 
        //If we have one field per packet, we can. The check in decode_nal_units() is not good enough
1321
 
        //to find this yet, so we assume the worst for now.
1322
 
        //if (setup_finished)
1323
 
        //    ff_thread_finish_setup(s->avctx);
1324
 
        return;
1325
 
    }
1326
 
 
1327
 
    cur->interlaced_frame = 0;
1328
 
    cur->repeat_pict = 0;
1329
 
 
1330
 
    /* Signal interlacing information externally. */
1331
 
    /* Prioritize picture timing SEI information over used decoding process if it exists. */
1332
 
 
1333
 
    if(h->sps.pic_struct_present_flag){
1334
 
        switch (h->sei_pic_struct)
1335
 
        {
1336
 
        case SEI_PIC_STRUCT_FRAME:
1337
 
            break;
1338
 
        case SEI_PIC_STRUCT_TOP_FIELD:
1339
 
        case SEI_PIC_STRUCT_BOTTOM_FIELD:
1340
 
            cur->interlaced_frame = 1;
1341
 
            break;
1342
 
        case SEI_PIC_STRUCT_TOP_BOTTOM:
1343
 
        case SEI_PIC_STRUCT_BOTTOM_TOP:
1344
 
            if (FIELD_OR_MBAFF_PICTURE)
1345
 
                cur->interlaced_frame = 1;
1346
 
            else
1347
 
                // try to flag soft telecine progressive
1348
 
                cur->interlaced_frame = h->prev_interlaced_frame;
1349
 
            break;
1350
 
        case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
1351
 
        case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
1352
 
            // Signal the possibility of telecined film externally (pic_struct 5,6)
1353
 
            // From these hints, let the applications decide if they apply deinterlacing.
1354
 
            cur->repeat_pict = 1;
1355
 
            break;
1356
 
        case SEI_PIC_STRUCT_FRAME_DOUBLING:
1357
 
            // Force progressive here, as doubling interlaced frame is a bad idea.
1358
 
            cur->repeat_pict = 2;
1359
 
            break;
1360
 
        case SEI_PIC_STRUCT_FRAME_TRIPLING:
1361
 
            cur->repeat_pict = 4;
1362
 
            break;
1363
 
        }
1364
 
 
1365
 
        if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
1366
 
            cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;
1367
 
    }else{
1368
 
        /* Derive interlacing flag from used decoding process. */
1369
 
        cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
1370
 
    }
1371
 
    h->prev_interlaced_frame = cur->interlaced_frame;
1372
 
 
1373
 
    if (cur->field_poc[0] != cur->field_poc[1]){
1374
 
        /* Derive top_field_first from field pocs. */
1375
 
        cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];
1376
 
    }else{
1377
 
        if(cur->interlaced_frame || h->sps.pic_struct_present_flag){
1378
 
            /* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */
1379
 
            if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM
1380
 
              || h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
1381
 
                cur->top_field_first = 1;
1382
 
            else
1383
 
                cur->top_field_first = 0;
1384
 
        }else{
1385
 
            /* Most likely progressive */
1386
 
            cur->top_field_first = 0;
1387
 
        }
1388
 
    }
1389
 
 
1390
 
    //FIXME do something with unavailable reference frames
1391
 
 
1392
 
    /* Sort B-frames into display order */
1393
 
 
1394
 
    if(h->sps.bitstream_restriction_flag
1395
 
       && s->avctx->has_b_frames < h->sps.num_reorder_frames){
1396
 
        s->avctx->has_b_frames = h->sps.num_reorder_frames;
1397
 
        s->low_delay = 0;
1398
 
    }
1399
 
 
1400
 
    if(   s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT
1401
 
       && !h->sps.bitstream_restriction_flag){
1402
 
        s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;
1403
 
        s->low_delay= 0;
1404
 
    }
1405
 
 
1406
 
    pics = 0;
1407
 
    while(h->delayed_pic[pics]) pics++;
1408
 
 
1409
 
    assert(pics <= MAX_DELAYED_PIC_COUNT);
1410
 
 
1411
 
    h->delayed_pic[pics++] = cur;
1412
 
    if(cur->reference == 0)
1413
 
        cur->reference = DELAYED_PIC_REF;
1414
 
 
1415
 
    out = h->delayed_pic[0];
1416
 
    out_idx = 0;
1417
 
    for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
1418
 
        if(h->delayed_pic[i]->poc < out->poc){
1419
 
            out = h->delayed_pic[i];
1420
 
            out_idx = i;
1421
 
        }
1422
 
    if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))
1423
 
        h->next_outputed_poc= INT_MIN;
1424
 
    out_of_order = out->poc < h->next_outputed_poc;
1425
 
 
1426
 
    if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
1427
 
        { }
1428
 
    else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)
1429
 
       || (s->low_delay &&
1430
 
        ((h->next_outputed_poc != INT_MIN && out->poc > h->next_outputed_poc + 2)
1431
 
         || cur->pict_type == AV_PICTURE_TYPE_B)))
1432
 
    {
1433
 
        s->low_delay = 0;
1434
 
        s->avctx->has_b_frames++;
1435
 
    }
1436
 
 
1437
 
    if(out_of_order || pics > s->avctx->has_b_frames){
1438
 
        out->reference &= ~DELAYED_PIC_REF;
1439
 
        out->owner2 = s; // for frame threading, the owner must be the second field's thread
1440
 
                         // or else the first thread can release the picture and reuse it unsafely
1441
 
        for(i=out_idx; h->delayed_pic[i]; i++)
1442
 
            h->delayed_pic[i] = h->delayed_pic[i+1];
1443
 
    }
1444
 
    if(!out_of_order && pics > s->avctx->has_b_frames){
1445
 
        h->next_output_pic = out;
1446
 
        if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {
1447
 
            h->next_outputed_poc = INT_MIN;
1448
 
        } else
1449
 
            h->next_outputed_poc = out->poc;
1450
 
    }else{
1451
 
        av_log(s->avctx, AV_LOG_DEBUG, "no picture\n");
1452
 
    }
1453
 
 
1454
 
    if (setup_finished)
1455
 
        ff_thread_finish_setup(s->avctx);
1456
 
}
1457
 
 
1458
 
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 chroma444, int simple){
1459
 
    MpegEncContext * const s = &h->s;
1460
 
    uint8_t *top_border;
1461
 
    int top_idx = 1;
1462
 
    const int pixel_shift = h->pixel_shift;
1463
 
 
1464
 
    src_y  -=   linesize;
1465
 
    src_cb -= uvlinesize;
1466
 
    src_cr -= uvlinesize;
1467
 
 
1468
 
    if(!simple && FRAME_MBAFF){
1469
 
        if(s->mb_y&1){
1470
 
            if(!MB_MBAFF){
1471
 
                top_border = h->top_borders[0][s->mb_x];
1472
 
                AV_COPY128(top_border, src_y + 15*linesize);
1473
 
                if (pixel_shift)
1474
 
                    AV_COPY128(top_border+16, src_y+15*linesize+16);
1475
 
                if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1476
 
                    if(chroma444){
1477
 
                        if (pixel_shift){
1478
 
                            AV_COPY128(top_border+32, src_cb + 15*uvlinesize);
1479
 
                            AV_COPY128(top_border+48, src_cb + 15*uvlinesize+16);
1480
 
                            AV_COPY128(top_border+64, src_cr + 15*uvlinesize);
1481
 
                            AV_COPY128(top_border+80, src_cr + 15*uvlinesize+16);
1482
 
                        } else {
1483
 
                            AV_COPY128(top_border+16, src_cb + 15*uvlinesize);
1484
 
                            AV_COPY128(top_border+32, src_cr + 15*uvlinesize);
1485
 
                        }
1486
 
                    } else {
1487
 
                        if (pixel_shift) {
1488
 
                            AV_COPY128(top_border+32, src_cb+7*uvlinesize);
1489
 
                            AV_COPY128(top_border+48, src_cr+7*uvlinesize);
1490
 
                        } else {
1491
 
                            AV_COPY64(top_border+16, src_cb+7*uvlinesize);
1492
 
                            AV_COPY64(top_border+24, src_cr+7*uvlinesize);
1493
 
                        }
1494
 
                    }
1495
 
                }
1496
 
            }
1497
 
        }else if(MB_MBAFF){
1498
 
            top_idx = 0;
1499
 
        }else
1500
 
            return;
1501
 
    }
1502
 
 
1503
 
    top_border = h->top_borders[top_idx][s->mb_x];
1504
 
    // There are two lines saved, the line above the the top macroblock of a pair,
1505
 
    // and the line above the bottom macroblock
1506
 
    AV_COPY128(top_border, src_y + 16*linesize);
1507
 
    if (pixel_shift)
1508
 
        AV_COPY128(top_border+16, src_y+16*linesize+16);
1509
 
 
1510
 
    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1511
 
        if(chroma444){
1512
 
            if (pixel_shift){
1513
 
                AV_COPY128(top_border+32, src_cb + 16*linesize);
1514
 
                AV_COPY128(top_border+48, src_cb + 16*linesize+16);
1515
 
                AV_COPY128(top_border+64, src_cr + 16*linesize);
1516
 
                AV_COPY128(top_border+80, src_cr + 16*linesize+16);
1517
 
            } else {
1518
 
                AV_COPY128(top_border+16, src_cb + 16*linesize);
1519
 
                AV_COPY128(top_border+32, src_cr + 16*linesize);
1520
 
            }
1521
 
        } else {
1522
 
            if (pixel_shift) {
1523
 
                AV_COPY128(top_border+32, src_cb+8*uvlinesize);
1524
 
                AV_COPY128(top_border+48, src_cr+8*uvlinesize);
1525
 
            } else {
1526
 
                AV_COPY64(top_border+16, src_cb+8*uvlinesize);
1527
 
                AV_COPY64(top_border+24, src_cr+8*uvlinesize);
1528
 
            }
1529
 
        }
1530
 
    }
1531
 
}
1532
 
 
1533
 
static inline void xchg_mb_border(H264Context *h, uint8_t *src_y,
1534
 
                                  uint8_t *src_cb, uint8_t *src_cr,
1535
 
                                  int linesize, int uvlinesize,
1536
 
                                  int xchg, int chroma444,
1537
 
                                  int simple, int pixel_shift){
1538
 
    MpegEncContext * const s = &h->s;
1539
 
    int deblock_topleft;
1540
 
    int deblock_top;
1541
 
    int top_idx = 1;
1542
 
    uint8_t *top_border_m1;
1543
 
    uint8_t *top_border;
1544
 
 
1545
 
    if(!simple && FRAME_MBAFF){
1546
 
        if(s->mb_y&1){
1547
 
            if(!MB_MBAFF)
1548
 
                return;
1549
 
        }else{
1550
 
            top_idx = MB_MBAFF ? 0 : 1;
1551
 
        }
1552
 
    }
1553
 
 
1554
 
    if(h->deblocking_filter == 2) {
1555
 
        deblock_topleft = h->slice_table[h->mb_xy - 1 - s->mb_stride] == h->slice_num;
1556
 
        deblock_top     = h->top_type;
1557
 
    } else {
1558
 
        deblock_topleft = (s->mb_x > 0);
1559
 
        deblock_top     = (s->mb_y > !!MB_FIELD);
1560
 
    }
1561
 
 
1562
 
    src_y  -=   linesize + 1 + pixel_shift;
1563
 
    src_cb -= uvlinesize + 1 + pixel_shift;
1564
 
    src_cr -= uvlinesize + 1 + pixel_shift;
1565
 
 
1566
 
    top_border_m1 = h->top_borders[top_idx][s->mb_x-1];
1567
 
    top_border    = h->top_borders[top_idx][s->mb_x];
1568
 
 
1569
 
#define XCHG(a,b,xchg)\
1570
 
    if (pixel_shift) {\
1571
 
        if (xchg) {\
1572
 
            AV_SWAP64(b+0,a+0);\
1573
 
            AV_SWAP64(b+8,a+8);\
1574
 
        } else {\
1575
 
            AV_COPY128(b,a); \
1576
 
        }\
1577
 
    } else \
1578
 
if (xchg) AV_SWAP64(b,a);\
1579
 
else      AV_COPY64(b,a);
1580
 
 
1581
 
    if(deblock_top){
1582
 
        if(deblock_topleft){
1583
 
            XCHG(top_border_m1 + (8 << pixel_shift), src_y - (7 << pixel_shift), 1);
1584
 
        }
1585
 
        XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);
1586
 
        XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);
1587
 
        if(s->mb_x+1 < s->mb_width){
1588
 
            XCHG(h->top_borders[top_idx][s->mb_x+1], src_y + (17 << pixel_shift), 1);
1589
 
        }
1590
 
    }
1591
 
    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1592
 
        if(chroma444){
1593
 
            if(deblock_topleft){
1594
 
                XCHG(top_border_m1 + (24 << pixel_shift), src_cb - (7 << pixel_shift), 1);
1595
 
                XCHG(top_border_m1 + (40 << pixel_shift), src_cr - (7 << pixel_shift), 1);
1596
 
            }
1597
 
            XCHG(top_border + (16 << pixel_shift), src_cb + (1 << pixel_shift), xchg);
1598
 
            XCHG(top_border + (24 << pixel_shift), src_cb + (9 << pixel_shift), 1);
1599
 
            XCHG(top_border + (32 << pixel_shift), src_cr + (1 << pixel_shift), xchg);
1600
 
            XCHG(top_border + (40 << pixel_shift), src_cr + (9 << pixel_shift), 1);
1601
 
            if(s->mb_x+1 < s->mb_width){
1602
 
                XCHG(h->top_borders[top_idx][s->mb_x+1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
1603
 
                XCHG(h->top_borders[top_idx][s->mb_x+1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1);
1604
 
            }
1605
 
        } else {
1606
 
            if(deblock_top){
1607
 
                if(deblock_topleft){
1608
 
                    XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
1609
 
                    XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
1610
 
                }
1611
 
                XCHG(top_border + (16 << pixel_shift), src_cb+1+pixel_shift, 1);
1612
 
                XCHG(top_border + (24 << pixel_shift), src_cr+1+pixel_shift, 1);
1613
 
            }
1614
 
        }
1615
 
    }
1616
 
}
1617
 
 
1618
 
static av_always_inline int dctcoef_get(DCTELEM *mb, int high_bit_depth, int index) {
1619
 
    if (high_bit_depth) {
1620
 
        return AV_RN32A(((int32_t*)mb) + index);
1621
 
    } else
1622
 
        return AV_RN16A(mb + index);
1623
 
}
1624
 
 
1625
 
static av_always_inline void dctcoef_set(DCTELEM *mb, int high_bit_depth, int index, int value) {
1626
 
    if (high_bit_depth) {
1627
 
        AV_WN32A(((int32_t*)mb) + index, value);
1628
 
    } else
1629
 
        AV_WN16A(mb + index, value);
1630
 
}
1631
 
 
1632
 
static av_always_inline void hl_decode_mb_predict_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass,
1633
 
                                                       int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)
1634
 
{
1635
 
    MpegEncContext * const s = &h->s;
1636
 
    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
1637
 
    void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
1638
 
    int i;
1639
 
    int qscale = p == 0 ? s->qscale : h->chroma_qp[p-1];
1640
 
    block_offset += 16*p;
1641
 
    if(IS_INTRA4x4(mb_type)){
1642
 
        if(simple || !s->encoding){
1643
 
            if(IS_8x8DCT(mb_type)){
1644
 
                if(transform_bypass){
1645
 
                    idct_dc_add =
1646
 
                    idct_add    = s->dsp.add_pixels8;
1647
 
                }else{
1648
 
                    idct_dc_add = h->h264dsp.h264_idct8_dc_add;
1649
 
                    idct_add    = h->h264dsp.h264_idct8_add;
1650
 
                }
1651
 
                for(i=0; i<16; i+=4){
1652
 
                    uint8_t * const ptr= dest_y + block_offset[i];
1653
 
                    const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
1654
 
                    if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1655
 
                        h->hpc.pred8x8l_add[dir](ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);
1656
 
                    }else{
1657
 
                        const int nnz = h->non_zero_count_cache[ scan8[i+p*16] ];
1658
 
                        h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
1659
 
                                                    (h->topright_samples_available<<i)&0x4000, linesize);
1660
 
                        if(nnz){
1661
 
                            if(nnz == 1 && dctcoef_get(h->mb, pixel_shift, i*16+p*256))
1662
 
                                idct_dc_add(ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);
1663
 
                            else
1664
 
                                idct_add   (ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);
1665
 
                        }
1666
 
                    }
1667
 
                }
1668
 
            }else{
1669
 
                if(transform_bypass){
1670
 
                    idct_dc_add =
1671
 
                    idct_add    = s->dsp.add_pixels4;
1672
 
                }else{
1673
 
                    idct_dc_add = h->h264dsp.h264_idct_dc_add;
1674
 
                    idct_add    = h->h264dsp.h264_idct_add;
1675
 
                }
1676
 
                for(i=0; i<16; i++){
1677
 
                    uint8_t * const ptr= dest_y + block_offset[i];
1678
 
                    const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
1679
 
 
1680
 
                    if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1681
 
                        h->hpc.pred4x4_add[dir](ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);
1682
 
                    }else{
1683
 
                        uint8_t *topright;
1684
 
                        int nnz, tr;
1685
 
                        uint64_t tr_high;
1686
 
                        if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
1687
 
                            const int topright_avail= (h->topright_samples_available<<i)&0x8000;
1688
 
                            assert(s->mb_y || linesize <= block_offset[i]);
1689
 
                            if(!topright_avail){
1690
 
                                if (pixel_shift) {
1691
 
                                    tr_high= ((uint16_t*)ptr)[3 - linesize/2]*0x0001000100010001ULL;
1692
 
                                    topright= (uint8_t*) &tr_high;
1693
 
                                } else {
1694
 
                                    tr= ptr[3 - linesize]*0x01010101;
1695
 
                                    topright= (uint8_t*) &tr;
1696
 
                                }
1697
 
                            }else
1698
 
                                topright= ptr + (4 << pixel_shift) - linesize;
1699
 
                        }else
1700
 
                            topright= NULL;
1701
 
 
1702
 
                        h->hpc.pred4x4[ dir ](ptr, topright, linesize);
1703
 
                        nnz = h->non_zero_count_cache[ scan8[i+p*16] ];
1704
 
                        if(nnz){
1705
 
                            if(is_h264){
1706
 
                                if(nnz == 1 && dctcoef_get(h->mb, pixel_shift, i*16+p*256))
1707
 
                                    idct_dc_add(ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);
1708
 
                                else
1709
 
                                    idct_add   (ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);
1710
 
                            }else
1711
 
                                ff_svq3_add_idct_c(ptr, h->mb + i*16+p*256, linesize, qscale, 0);
1712
 
                        }
1713
 
                    }
1714
 
                }
1715
 
            }
1716
 
        }
1717
 
    }else{
1718
 
        h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
1719
 
        if(is_h264){
1720
 
            if(h->non_zero_count_cache[ scan8[LUMA_DC_BLOCK_INDEX+p] ]){
1721
 
                if(!transform_bypass)
1722
 
                    h->h264dsp.h264_luma_dc_dequant_idct(h->mb+(p*256 << pixel_shift), h->mb_luma_dc[p], h->dequant4_coeff[p][qscale][0]);
1723
 
                else{
1724
 
                    static const uint8_t dc_mapping[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,
1725
 
                                                            8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};
1726
 
                    for(i = 0; i < 16; i++)
1727
 
                        dctcoef_set(h->mb+p*256, pixel_shift, dc_mapping[i], dctcoef_get(h->mb_luma_dc[p], pixel_shift, i));
1728
 
                }
1729
 
            }
1730
 
        }else
1731
 
            ff_svq3_luma_dc_dequant_idct_c(h->mb+p*256, h->mb_luma_dc[p], qscale);
1732
 
    }
1733
 
}
1734
 
 
1735
 
static av_always_inline void hl_decode_mb_idct_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass,
1736
 
                                                    int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)
1737
 
{
1738
 
    MpegEncContext * const s = &h->s;
1739
 
    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
1740
 
    int i;
1741
 
    block_offset += 16*p;
1742
 
    if(!IS_INTRA4x4(mb_type)){
1743
 
        if(is_h264){
1744
 
            if(IS_INTRA16x16(mb_type)){
1745
 
                if(transform_bypass){
1746
 
                    if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
1747
 
                        h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize);
1748
 
                    }else{
1749
 
                        for(i=0; i<16; i++){
1750
 
                            if(h->non_zero_count_cache[ scan8[i+p*16] ] || dctcoef_get(h->mb, pixel_shift, i*16+p*256))
1751
 
                                s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + (i*16+p*256 << pixel_shift), linesize);
1752
 
                        }
1753
 
                    }
1754
 
                }else{
1755
 
                    h->h264dsp.h264_idct_add16intra(dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize, h->non_zero_count_cache+p*5*8);
1756
 
                }
1757
 
            }else if(h->cbp&15){
1758
 
                if(transform_bypass){
1759
 
                    const int di = IS_8x8DCT(mb_type) ? 4 : 1;
1760
 
                    idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
1761
 
                    for(i=0; i<16; i+=di){
1762
 
                        if(h->non_zero_count_cache[ scan8[i+p*16] ]){
1763
 
                            idct_add(dest_y + block_offset[i], h->mb + (i*16+p*256 << pixel_shift), linesize);
1764
 
                        }
1765
 
                    }
1766
 
                }else{
1767
 
                    if(IS_8x8DCT(mb_type)){
1768
 
                        h->h264dsp.h264_idct8_add4(dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize, h->non_zero_count_cache+p*5*8);
1769
 
                    }else{
1770
 
                        h->h264dsp.h264_idct_add16(dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize, h->non_zero_count_cache+p*5*8);
1771
 
                    }
1772
 
                }
1773
 
            }
1774
 
        }else{
1775
 
            for(i=0; i<16; i++){
1776
 
                if(h->non_zero_count_cache[ scan8[i+p*16] ] || h->mb[i*16+p*256]){ //FIXME benchmark weird rule, & below
1777
 
                    uint8_t * const ptr= dest_y + block_offset[i];
1778
 
                    ff_svq3_add_idct_c(ptr, h->mb + i*16 + p*256, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
1779
 
                }
1780
 
            }
1781
 
        }
1782
 
    }
1783
 
}
1784
 
 
1785
 
static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple, int pixel_shift){
1786
 
    MpegEncContext * const s = &h->s;
1787
 
    const int mb_x= s->mb_x;
1788
 
    const int mb_y= s->mb_y;
1789
 
    const int mb_xy= h->mb_xy;
1790
 
    const int mb_type= s->current_picture.mb_type[mb_xy];
1791
 
    uint8_t  *dest_y, *dest_cb, *dest_cr;
1792
 
    int linesize, uvlinesize /*dct_offset*/;
1793
 
    int i, j;
1794
 
    int *block_offset = &h->block_offset[0];
1795
 
    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
1796
 
    /* is_h264 should always be true if SVQ3 is disabled. */
1797
 
    const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;
1798
 
    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
1799
 
 
1800
 
    dest_y  = s->current_picture.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize  ) * 16;
1801
 
    dest_cb = s->current_picture.data[1] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;
1802
 
    dest_cr = s->current_picture.data[2] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;
1803
 
 
1804
 
    s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);
1805
 
    s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + (64 << pixel_shift), dest_cr - dest_cb, 2);
1806
 
 
1807
 
    h->list_counts[mb_xy]= h->list_count;
1808
 
 
1809
 
    if (!simple && MB_FIELD) {
1810
 
        linesize   = h->mb_linesize   = s->linesize * 2;
1811
 
        uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
1812
 
        block_offset = &h->block_offset[48];
1813
 
        if(mb_y&1){ //FIXME move out of this function?
1814
 
            dest_y -= s->linesize*15;
1815
 
            dest_cb-= s->uvlinesize*7;
1816
 
            dest_cr-= s->uvlinesize*7;
1817
 
        }
1818
 
        if(FRAME_MBAFF) {
1819
 
            int list;
1820
 
            for(list=0; list<h->list_count; list++){
1821
 
                if(!USES_LIST(mb_type, list))
1822
 
                    continue;
1823
 
                if(IS_16X16(mb_type)){
1824
 
                    int8_t *ref = &h->ref_cache[list][scan8[0]];
1825
 
                    fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
1826
 
                }else{
1827
 
                    for(i=0; i<16; i+=4){
1828
 
                        int ref = h->ref_cache[list][scan8[i]];
1829
 
                        if(ref >= 0)
1830
 
                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
1831
 
                    }
1832
 
                }
1833
 
            }
1834
 
        }
1835
 
    } else {
1836
 
        linesize   = h->mb_linesize   = s->linesize;
1837
 
        uvlinesize = h->mb_uvlinesize = s->uvlinesize;
1838
 
//        dct_offset = s->linesize * 16;
1839
 
    }
1840
 
 
1841
 
    if (!simple && IS_INTRA_PCM(mb_type)) {
1842
 
        if (pixel_shift) {
1843
 
            const int bit_depth = h->sps.bit_depth_luma;
1844
 
            int j;
1845
 
            GetBitContext gb;
1846
 
            init_get_bits(&gb, (uint8_t*)h->mb, 384*bit_depth);
1847
 
 
1848
 
            for (i = 0; i < 16; i++) {
1849
 
                uint16_t *tmp_y  = (uint16_t*)(dest_y  + i*linesize);
1850
 
                for (j = 0; j < 16; j++)
1851
 
                    tmp_y[j] = get_bits(&gb, bit_depth);
1852
 
            }
1853
 
            if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1854
 
                for (i = 0; i < 8; i++) {
1855
 
                    uint16_t *tmp_cb = (uint16_t*)(dest_cb + i*uvlinesize);
1856
 
                    for (j = 0; j < 8; j++)
1857
 
                        tmp_cb[j] = get_bits(&gb, bit_depth);
1858
 
                }
1859
 
                for (i = 0; i < 8; i++) {
1860
 
                    uint16_t *tmp_cr = (uint16_t*)(dest_cr + i*uvlinesize);
1861
 
                    for (j = 0; j < 8; j++)
1862
 
                        tmp_cr[j] = get_bits(&gb, bit_depth);
1863
 
                }
1864
 
            }
1865
 
        } else {
1866
 
            for (i=0; i<16; i++) {
1867
 
                memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);
1868
 
            }
1869
 
            if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1870
 
                for (i=0; i<8; i++) {
1871
 
                    memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);
1872
 
                    memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);
1873
 
                }
1874
 
            }
1875
 
        }
1876
 
    } else {
1877
 
        if(IS_INTRA(mb_type)){
1878
 
            if(h->deblocking_filter)
1879
 
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, 0, simple, pixel_shift);
1880
 
 
1881
 
            if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1882
 
                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
1883
 
                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
1884
 
            }
1885
 
 
1886
 
            hl_decode_mb_predict_luma(h, mb_type, is_h264, simple, transform_bypass, pixel_shift, block_offset, linesize, dest_y, 0);
1887
 
 
1888
 
            if(h->deblocking_filter)
1889
 
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, 0, simple, pixel_shift);
1890
 
        }else if(is_h264){
1891
 
            if (pixel_shift) {
1892
 
                hl_motion_16(h, dest_y, dest_cb, dest_cr,
1893
 
                             s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
1894
 
                             s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
1895
 
                             h->h264dsp.weight_h264_pixels_tab,
1896
 
                             h->h264dsp.biweight_h264_pixels_tab, 0);
1897
 
            } else
1898
 
                hl_motion_8(h, dest_y, dest_cb, dest_cr,
1899
 
                            s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
1900
 
                            s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
1901
 
                            h->h264dsp.weight_h264_pixels_tab,
1902
 
                            h->h264dsp.biweight_h264_pixels_tab, 0);
1903
 
        }
1904
 
 
1905
 
        hl_decode_mb_idct_luma(h, mb_type, is_h264, simple, transform_bypass, pixel_shift, block_offset, linesize, dest_y, 0);
1906
 
 
1907
 
        if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
1908
 
            uint8_t *dest[2] = {dest_cb, dest_cr};
1909
 
            if(transform_bypass){
1910
 
                if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
1911
 
                    h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + (16*16*1 << pixel_shift), uvlinesize);
1912
 
                    h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 32, h->mb + (16*16*2 << pixel_shift), uvlinesize);
1913
 
                }else{
1914
 
                    idct_add = s->dsp.add_pixels4;
1915
 
                    for(j=1; j<3; j++){
1916
 
                        for(i=j*16; i<j*16+4; i++){
1917
 
                            if(h->non_zero_count_cache[ scan8[i] ] || dctcoef_get(h->mb, pixel_shift, i*16))
1918
 
                                idct_add   (dest[j-1] + block_offset[i], h->mb + (i*16 << pixel_shift), uvlinesize);
1919
 
                        }
1920
 
                    }
1921
 
                }
1922
 
            }else{
1923
 
                if(is_h264){
1924
 
                    if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+0] ])
1925
 
                        h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16*16*1 << pixel_shift), h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
1926
 
                    if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+1] ])
1927
 
                        h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16*16*2 << pixel_shift), h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
1928
 
                    h->h264dsp.h264_idct_add8(dest, block_offset,
1929
 
                                              h->mb, uvlinesize,
1930
 
                                              h->non_zero_count_cache);
1931
 
                }else{
1932
 
                    h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*1, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
1933
 
                    h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*2, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
1934
 
                    for(j=1; j<3; j++){
1935
 
                        for(i=j*16; i<j*16+4; i++){
1936
 
                            if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
1937
 
                                uint8_t * const ptr= dest[j-1] + block_offset[i];
1938
 
                                ff_svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
1939
 
                            }
1940
 
                        }
1941
 
                    }
1942
 
                }
1943
 
            }
1944
 
        }
1945
 
    }
1946
 
    if(h->cbp || IS_INTRA(mb_type))
1947
 
    {
1948
 
        s->dsp.clear_blocks(h->mb);
1949
 
        s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));
1950
 
    }
1951
 
}
1952
 
 
1953
 
static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simple, int pixel_shift){
1954
 
    MpegEncContext * const s = &h->s;
1955
 
    const int mb_x= s->mb_x;
1956
 
    const int mb_y= s->mb_y;
1957
 
    const int mb_xy= h->mb_xy;
1958
 
    const int mb_type= s->current_picture.mb_type[mb_xy];
1959
 
    uint8_t  *dest[3];
1960
 
    int linesize;
1961
 
    int i, j, p;
1962
 
    int *block_offset = &h->block_offset[0];
1963
 
    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
1964
 
    const int plane_count = (simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) ? 3 : 1;
1965
 
 
1966
 
    for (p = 0; p < plane_count; p++)
1967
 
    {
1968
 
        dest[p] = s->current_picture.data[p] + ((mb_x << pixel_shift) + mb_y * s->linesize) * 16;
1969
 
        s->dsp.prefetch(dest[p] + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);
1970
 
    }
1971
 
 
1972
 
    h->list_counts[mb_xy]= h->list_count;
1973
 
 
1974
 
    if (!simple && MB_FIELD) {
1975
 
        linesize   = h->mb_linesize = h->mb_uvlinesize = s->linesize * 2;
1976
 
        block_offset = &h->block_offset[48];
1977
 
        if(mb_y&1) //FIXME move out of this function?
1978
 
            for (p = 0; p < 3; p++)
1979
 
                dest[p] -= s->linesize*15;
1980
 
        if(FRAME_MBAFF) {
1981
 
            int list;
1982
 
            for(list=0; list<h->list_count; list++){
1983
 
                if(!USES_LIST(mb_type, list))
1984
 
                    continue;
1985
 
                if(IS_16X16(mb_type)){
1986
 
                    int8_t *ref = &h->ref_cache[list][scan8[0]];
1987
 
                    fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
1988
 
                }else{
1989
 
                    for(i=0; i<16; i+=4){
1990
 
                        int ref = h->ref_cache[list][scan8[i]];
1991
 
                        if(ref >= 0)
1992
 
                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
1993
 
                    }
1994
 
                }
1995
 
            }
1996
 
        }
1997
 
    } else {
1998
 
        linesize   = h->mb_linesize = h->mb_uvlinesize = s->linesize;
1999
 
    }
2000
 
 
2001
 
    if (!simple && IS_INTRA_PCM(mb_type)) {
2002
 
        if (pixel_shift) {
2003
 
            const int bit_depth = h->sps.bit_depth_luma;
2004
 
            GetBitContext gb;
2005
 
            init_get_bits(&gb, (uint8_t*)h->mb, 768*bit_depth);
2006
 
 
2007
 
            for (p = 0; p < plane_count; p++) {
2008
 
                for (i = 0; i < 16; i++) {
2009
 
                    uint16_t *tmp = (uint16_t*)(dest[p] + i*linesize);
2010
 
                    for (j = 0; j < 16; j++)
2011
 
                        tmp[j] = get_bits(&gb, bit_depth);
2012
 
                }
2013
 
            }
2014
 
        } else {
2015
 
            for (p = 0; p < plane_count; p++) {
2016
 
                for (i = 0; i < 16; i++) {
2017
 
                    memcpy(dest[p] + i*linesize, h->mb + p*128 + i*8, 16);
2018
 
                }
2019
 
            }
2020
 
        }
2021
 
    } else {
2022
 
        if(IS_INTRA(mb_type)){
2023
 
            if(h->deblocking_filter)
2024
 
                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 1, 1, simple, pixel_shift);
2025
 
 
2026
 
            for (p = 0; p < plane_count; p++)
2027
 
                hl_decode_mb_predict_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);
2028
 
 
2029
 
            if(h->deblocking_filter)
2030
 
                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 0, 1, simple, pixel_shift);
2031
 
        }else{
2032
 
            if (pixel_shift) {
2033
 
                hl_motion_16(h, dest[0], dest[1], dest[2],
2034
 
                             s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
2035
 
                             s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
2036
 
                             h->h264dsp.weight_h264_pixels_tab,
2037
 
                             h->h264dsp.biweight_h264_pixels_tab, 1);
2038
 
            } else
2039
 
                hl_motion_8(h, dest[0], dest[1], dest[2],
2040
 
                            s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
2041
 
                            s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
2042
 
                            h->h264dsp.weight_h264_pixels_tab,
2043
 
                            h->h264dsp.biweight_h264_pixels_tab, 1);
2044
 
        }
2045
 
 
2046
 
        for (p = 0; p < plane_count; p++)
2047
 
            hl_decode_mb_idct_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);
2048
 
    }
2049
 
    if(h->cbp || IS_INTRA(mb_type))
2050
 
    {
2051
 
        s->dsp.clear_blocks(h->mb);
2052
 
        s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));
2053
 
    }
2054
 
}
2055
 
 
2056
 
/**
2057
 
 * Process a macroblock; this case avoids checks for expensive uncommon cases.
2058
 
 */
2059
 
#define hl_decode_mb_simple(sh, bits) \
2060
 
static void hl_decode_mb_simple_ ## bits(H264Context *h){ \
2061
 
    hl_decode_mb_internal(h, 1, sh); \
2062
 
}
2063
 
hl_decode_mb_simple(0, 8);
2064
 
hl_decode_mb_simple(1, 16);
2065
 
 
2066
 
/**
2067
 
 * Process a macroblock; this handles edge cases, such as interlacing.
2068
 
 */
2069
 
static void av_noinline hl_decode_mb_complex(H264Context *h){
2070
 
    hl_decode_mb_internal(h, 0, h->pixel_shift);
2071
 
}
2072
 
 
2073
 
static void av_noinline hl_decode_mb_444_complex(H264Context *h){
2074
 
    hl_decode_mb_444_internal(h, 0, h->pixel_shift);
2075
 
}
2076
 
 
2077
 
static void av_noinline hl_decode_mb_444_simple(H264Context *h){
2078
 
    hl_decode_mb_444_internal(h, 1, 0);
2079
 
}
2080
 
 
2081
 
void ff_h264_hl_decode_mb(H264Context *h){
2082
 
    MpegEncContext * const s = &h->s;
2083
 
    const int mb_xy= h->mb_xy;
2084
 
    const int mb_type= s->current_picture.mb_type[mb_xy];
2085
 
    int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
2086
 
 
2087
 
    if (CHROMA444) {
2088
 
        if(is_complex || h->pixel_shift)
2089
 
            hl_decode_mb_444_complex(h);
2090
 
        else
2091
 
            hl_decode_mb_444_simple(h);
2092
 
    } else if (is_complex) {
2093
 
        hl_decode_mb_complex(h);
2094
 
    } else if (h->pixel_shift) {
2095
 
        hl_decode_mb_simple_16(h);
2096
 
    } else
2097
 
        hl_decode_mb_simple_8(h);
2098
 
}
2099
 
 
2100
 
static int pred_weight_table(H264Context *h){
2101
 
    MpegEncContext * const s = &h->s;
2102
 
    int list, i;
2103
 
    int luma_def, chroma_def;
2104
 
 
2105
 
    h->use_weight= 0;
2106
 
    h->use_weight_chroma= 0;
2107
 
    h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
2108
 
    if(h->sps.chroma_format_idc)
2109
 
        h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
2110
 
    luma_def = 1<<h->luma_log2_weight_denom;
2111
 
    chroma_def = 1<<h->chroma_log2_weight_denom;
2112
 
 
2113
 
    for(list=0; list<2; list++){
2114
 
        h->luma_weight_flag[list]   = 0;
2115
 
        h->chroma_weight_flag[list] = 0;
2116
 
        for(i=0; i<h->ref_count[list]; i++){
2117
 
            int luma_weight_flag, chroma_weight_flag;
2118
 
 
2119
 
            luma_weight_flag= get_bits1(&s->gb);
2120
 
            if(luma_weight_flag){
2121
 
                h->luma_weight[i][list][0]= get_se_golomb(&s->gb);
2122
 
                h->luma_weight[i][list][1]= get_se_golomb(&s->gb);
2123
 
                if(   h->luma_weight[i][list][0] != luma_def
2124
 
                   || h->luma_weight[i][list][1] != 0) {
2125
 
                    h->use_weight= 1;
2126
 
                    h->luma_weight_flag[list]= 1;
2127
 
                }
2128
 
            }else{
2129
 
                h->luma_weight[i][list][0]= luma_def;
2130
 
                h->luma_weight[i][list][1]= 0;
2131
 
            }
2132
 
 
2133
 
            if(h->sps.chroma_format_idc){
2134
 
                chroma_weight_flag= get_bits1(&s->gb);
2135
 
                if(chroma_weight_flag){
2136
 
                    int j;
2137
 
                    for(j=0; j<2; j++){
2138
 
                        h->chroma_weight[i][list][j][0]= get_se_golomb(&s->gb);
2139
 
                        h->chroma_weight[i][list][j][1]= get_se_golomb(&s->gb);
2140
 
                        if(   h->chroma_weight[i][list][j][0] != chroma_def
2141
 
                           || h->chroma_weight[i][list][j][1] != 0) {
2142
 
                            h->use_weight_chroma= 1;
2143
 
                            h->chroma_weight_flag[list]= 1;
2144
 
                        }
2145
 
                    }
2146
 
                }else{
2147
 
                    int j;
2148
 
                    for(j=0; j<2; j++){
2149
 
                        h->chroma_weight[i][list][j][0]= chroma_def;
2150
 
                        h->chroma_weight[i][list][j][1]= 0;
2151
 
                    }
2152
 
                }
2153
 
            }
2154
 
        }
2155
 
        if(h->slice_type_nos != AV_PICTURE_TYPE_B) break;
2156
 
    }
2157
 
    h->use_weight= h->use_weight || h->use_weight_chroma;
2158
 
    return 0;
2159
 
}
2160
 
 
2161
 
/**
2162
 
 * Initialize implicit_weight table.
2163
 
 * @param field  0/1 initialize the weight for interlaced MBAFF
2164
 
 *                -1 initializes the rest
2165
 
 */
2166
 
static void implicit_weight_table(H264Context *h, int field){
2167
 
    MpegEncContext * const s = &h->s;
2168
 
    int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
2169
 
 
2170
 
    for (i = 0; i < 2; i++) {
2171
 
        h->luma_weight_flag[i]   = 0;
2172
 
        h->chroma_weight_flag[i] = 0;
2173
 
    }
2174
 
 
2175
 
    if(field < 0){
2176
 
        cur_poc = s->current_picture_ptr->poc;
2177
 
    if(   h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF
2178
 
       && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
2179
 
        h->use_weight= 0;
2180
 
        h->use_weight_chroma= 0;
2181
 
        return;
2182
 
    }
2183
 
        ref_start= 0;
2184
 
        ref_count0= h->ref_count[0];
2185
 
        ref_count1= h->ref_count[1];
2186
 
    }else{
2187
 
        cur_poc = s->current_picture_ptr->field_poc[field];
2188
 
        ref_start= 16;
2189
 
        ref_count0= 16+2*h->ref_count[0];
2190
 
        ref_count1= 16+2*h->ref_count[1];
2191
 
    }
2192
 
 
2193
 
    h->use_weight= 2;
2194
 
    h->use_weight_chroma= 2;
2195
 
    h->luma_log2_weight_denom= 5;
2196
 
    h->chroma_log2_weight_denom= 5;
2197
 
 
2198
 
    for(ref0=ref_start; ref0 < ref_count0; ref0++){
2199
 
        int poc0 = h->ref_list[0][ref0].poc;
2200
 
        for(ref1=ref_start; ref1 < ref_count1; ref1++){
2201
 
            int w = 32;
2202
 
            if (!h->ref_list[0][ref0].long_ref && !h->ref_list[1][ref1].long_ref) {
2203
 
                int poc1 = h->ref_list[1][ref1].poc;
2204
 
                int td = av_clip(poc1 - poc0, -128, 127);
2205
 
                if(td){
2206
 
                    int tb = av_clip(cur_poc - poc0, -128, 127);
2207
 
                    int tx = (16384 + (FFABS(td) >> 1)) / td;
2208
 
                    int dist_scale_factor = (tb*tx + 32) >> 8;
2209
 
                    if(dist_scale_factor >= -64 && dist_scale_factor <= 128)
2210
 
                        w = 64 - dist_scale_factor;
2211
 
                }
2212
 
            }
2213
 
            if(field<0){
2214
 
                h->implicit_weight[ref0][ref1][0]=
2215
 
                h->implicit_weight[ref0][ref1][1]= w;
2216
 
            }else{
2217
 
                h->implicit_weight[ref0][ref1][field]=w;
2218
 
            }
2219
 
        }
2220
 
    }
2221
 
}
2222
 
 
2223
 
/**
2224
 
 * instantaneous decoder refresh.
2225
 
 */
2226
 
static void idr(H264Context *h){
2227
 
    ff_h264_remove_all_refs(h);
2228
 
    h->prev_frame_num= 0;
2229
 
    h->prev_frame_num_offset= 0;
2230
 
    h->prev_poc_msb=
2231
 
    h->prev_poc_lsb= 0;
2232
 
}
2233
 
 
2234
 
/* forget old pics after a seek */
2235
 
static void flush_dpb(AVCodecContext *avctx){
2236
 
    H264Context *h= avctx->priv_data;
2237
 
    int i;
2238
 
    for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
2239
 
        if(h->delayed_pic[i])
2240
 
            h->delayed_pic[i]->reference= 0;
2241
 
        h->delayed_pic[i]= NULL;
2242
 
    }
2243
 
    h->outputed_poc=h->next_outputed_poc= INT_MIN;
2244
 
    h->prev_interlaced_frame = 1;
2245
 
    idr(h);
2246
 
    if(h->s.current_picture_ptr)
2247
 
        h->s.current_picture_ptr->reference= 0;
2248
 
    h->s.first_field= 0;
2249
 
    ff_h264_reset_sei(h);
2250
 
    ff_mpeg_flush(avctx);
2251
 
}
2252
 
 
2253
 
static int init_poc(H264Context *h){
2254
 
    MpegEncContext * const s = &h->s;
2255
 
    const int max_frame_num= 1<<h->sps.log2_max_frame_num;
2256
 
    int field_poc[2];
2257
 
    Picture *cur = s->current_picture_ptr;
2258
 
 
2259
 
    h->frame_num_offset= h->prev_frame_num_offset;
2260
 
    if(h->frame_num < h->prev_frame_num)
2261
 
        h->frame_num_offset += max_frame_num;
2262
 
 
2263
 
    if(h->sps.poc_type==0){
2264
 
        const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
2265
 
 
2266
 
        if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
2267
 
            h->poc_msb = h->prev_poc_msb + max_poc_lsb;
2268
 
        else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
2269
 
            h->poc_msb = h->prev_poc_msb - max_poc_lsb;
2270
 
        else
2271
 
            h->poc_msb = h->prev_poc_msb;
2272
 
//printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
2273
 
        field_poc[0] =
2274
 
        field_poc[1] = h->poc_msb + h->poc_lsb;
2275
 
        if(s->picture_structure == PICT_FRAME)
2276
 
            field_poc[1] += h->delta_poc_bottom;
2277
 
    }else if(h->sps.poc_type==1){
2278
 
        int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
2279
 
        int i;
2280
 
 
2281
 
        if(h->sps.poc_cycle_length != 0)
2282
 
            abs_frame_num = h->frame_num_offset + h->frame_num;
2283
 
        else
2284
 
            abs_frame_num = 0;
2285
 
 
2286
 
        if(h->nal_ref_idc==0 && abs_frame_num > 0)
2287
 
            abs_frame_num--;
2288
 
 
2289
 
        expected_delta_per_poc_cycle = 0;
2290
 
        for(i=0; i < h->sps.poc_cycle_length; i++)
2291
 
            expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
2292
 
 
2293
 
        if(abs_frame_num > 0){
2294
 
            int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
2295
 
            int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
2296
 
 
2297
 
            expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
2298
 
            for(i = 0; i <= frame_num_in_poc_cycle; i++)
2299
 
                expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
2300
 
        } else
2301
 
            expectedpoc = 0;
2302
 
 
2303
 
        if(h->nal_ref_idc == 0)
2304
 
            expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
2305
 
 
2306
 
        field_poc[0] = expectedpoc + h->delta_poc[0];
2307
 
        field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
2308
 
 
2309
 
        if(s->picture_structure == PICT_FRAME)
2310
 
            field_poc[1] += h->delta_poc[1];
2311
 
    }else{
2312
 
        int poc= 2*(h->frame_num_offset + h->frame_num);
2313
 
 
2314
 
        if(!h->nal_ref_idc)
2315
 
            poc--;
2316
 
 
2317
 
        field_poc[0]= poc;
2318
 
        field_poc[1]= poc;
2319
 
    }
2320
 
 
2321
 
    if(s->picture_structure != PICT_BOTTOM_FIELD)
2322
 
        s->current_picture_ptr->field_poc[0]= field_poc[0];
2323
 
    if(s->picture_structure != PICT_TOP_FIELD)
2324
 
        s->current_picture_ptr->field_poc[1]= field_poc[1];
2325
 
    cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
2326
 
 
2327
 
    return 0;
2328
 
}
2329
 
 
2330
 
 
2331
 
/**
2332
 
 * initialize scan tables
2333
 
 */
2334
 
static void init_scan_tables(H264Context *h){
2335
 
    int i;
2336
 
    for(i=0; i<16; i++){
2337
 
#define T(x) (x>>2) | ((x<<2) & 0xF)
2338
 
        h->zigzag_scan[i] = T(zigzag_scan[i]);
2339
 
        h-> field_scan[i] = T( field_scan[i]);
2340
 
#undef T
2341
 
    }
2342
 
    for(i=0; i<64; i++){
2343
 
#define T(x) (x>>3) | ((x&7)<<3)
2344
 
        h->zigzag_scan8x8[i]       = T(ff_zigzag_direct[i]);
2345
 
        h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
2346
 
        h->field_scan8x8[i]        = T(field_scan8x8[i]);
2347
 
        h->field_scan8x8_cavlc[i]  = T(field_scan8x8_cavlc[i]);
2348
 
#undef T
2349
 
    }
2350
 
    if(h->sps.transform_bypass){ //FIXME same ugly
2351
 
        h->zigzag_scan_q0          = zigzag_scan;
2352
 
        h->zigzag_scan8x8_q0       = ff_zigzag_direct;
2353
 
        h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
2354
 
        h->field_scan_q0           = field_scan;
2355
 
        h->field_scan8x8_q0        = field_scan8x8;
2356
 
        h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
2357
 
    }else{
2358
 
        h->zigzag_scan_q0          = h->zigzag_scan;
2359
 
        h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
2360
 
        h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
2361
 
        h->field_scan_q0           = h->field_scan;
2362
 
        h->field_scan8x8_q0        = h->field_scan8x8;
2363
 
        h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
2364
 
    }
2365
 
}
2366
 
 
2367
 
static void field_end(H264Context *h, int in_setup){
2368
 
    MpegEncContext * const s = &h->s;
2369
 
    AVCodecContext * const avctx= s->avctx;
2370
 
    s->mb_y= 0;
2371
 
 
2372
 
    if (!in_setup && !s->dropable)
2373
 
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, (16*s->mb_height >> FIELD_PICTURE) - 1,
2374
 
                                 s->picture_structure==PICT_BOTTOM_FIELD);
2375
 
 
2376
 
    if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2377
 
        ff_vdpau_h264_set_reference_frames(s);
2378
 
 
2379
 
    if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){
2380
 
        if(!s->dropable) {
2381
 
            ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
2382
 
            h->prev_poc_msb= h->poc_msb;
2383
 
            h->prev_poc_lsb= h->poc_lsb;
2384
 
        }
2385
 
        h->prev_frame_num_offset= h->frame_num_offset;
2386
 
        h->prev_frame_num= h->frame_num;
2387
 
        h->outputed_poc = h->next_outputed_poc;
2388
 
    }
2389
 
 
2390
 
    if (avctx->hwaccel) {
2391
 
        if (avctx->hwaccel->end_frame(avctx) < 0)
2392
 
            av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
2393
 
    }
2394
 
 
2395
 
    if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2396
 
        ff_vdpau_h264_picture_complete(s);
2397
 
 
2398
 
    /*
2399
 
     * FIXME: Error handling code does not seem to support interlaced
2400
 
     * when slices span multiple rows
2401
 
     * The ff_er_add_slice calls don't work right for bottom
2402
 
     * fields; they cause massive erroneous error concealing
2403
 
     * Error marking covers both fields (top and bottom).
2404
 
     * This causes a mismatched s->error_count
2405
 
     * and a bad error table. Further, the error count goes to
2406
 
     * INT_MAX when called for bottom field, because mb_y is
2407
 
     * past end by one (callers fault) and resync_mb_y != 0
2408
 
     * causes problems for the first MB line, too.
2409
 
     */
2410
 
    if (!FIELD_PICTURE)
2411
 
        ff_er_frame_end(s);
2412
 
 
2413
 
    MPV_frame_end(s);
2414
 
 
2415
 
    h->current_slice=0;
2416
 
}
2417
 
 
2418
 
/**
2419
 
 * Replicate H264 "master" context to thread contexts.
2420
 
 */
2421
 
static void clone_slice(H264Context *dst, H264Context *src)
2422
 
{
2423
 
    memcpy(dst->block_offset,     src->block_offset, sizeof(dst->block_offset));
2424
 
    dst->s.current_picture_ptr  = src->s.current_picture_ptr;
2425
 
    dst->s.current_picture      = src->s.current_picture;
2426
 
    dst->s.linesize             = src->s.linesize;
2427
 
    dst->s.uvlinesize           = src->s.uvlinesize;
2428
 
    dst->s.first_field          = src->s.first_field;
2429
 
 
2430
 
    dst->prev_poc_msb           = src->prev_poc_msb;
2431
 
    dst->prev_poc_lsb           = src->prev_poc_lsb;
2432
 
    dst->prev_frame_num_offset  = src->prev_frame_num_offset;
2433
 
    dst->prev_frame_num         = src->prev_frame_num;
2434
 
    dst->short_ref_count        = src->short_ref_count;
2435
 
 
2436
 
    memcpy(dst->short_ref,        src->short_ref,        sizeof(dst->short_ref));
2437
 
    memcpy(dst->long_ref,         src->long_ref,         sizeof(dst->long_ref));
2438
 
    memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));
2439
 
    memcpy(dst->ref_list,         src->ref_list,         sizeof(dst->ref_list));
2440
 
 
2441
 
    memcpy(dst->dequant4_coeff,   src->dequant4_coeff,   sizeof(src->dequant4_coeff));
2442
 
    memcpy(dst->dequant8_coeff,   src->dequant8_coeff,   sizeof(src->dequant8_coeff));
2443
 
}
2444
 
 
2445
 
/**
2446
 
 * computes profile from profile_idc and constraint_set?_flags
2447
 
 *
2448
 
 * @param sps SPS
2449
 
 *
2450
 
 * @return profile as defined by FF_PROFILE_H264_*
2451
 
 */
2452
 
int ff_h264_get_profile(SPS *sps)
2453
 
{
2454
 
    int profile = sps->profile_idc;
2455
 
 
2456
 
    switch(sps->profile_idc) {
2457
 
    case FF_PROFILE_H264_BASELINE:
2458
 
        // constraint_set1_flag set to 1
2459
 
        profile |= (sps->constraint_set_flags & 1<<1) ? FF_PROFILE_H264_CONSTRAINED : 0;
2460
 
        break;
2461
 
    case FF_PROFILE_H264_HIGH_10:
2462
 
    case FF_PROFILE_H264_HIGH_422:
2463
 
    case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
2464
 
        // constraint_set3_flag set to 1
2465
 
        profile |= (sps->constraint_set_flags & 1<<3) ? FF_PROFILE_H264_INTRA : 0;
2466
 
        break;
2467
 
    }
2468
 
 
2469
 
    return profile;
2470
 
}
2471
 
 
2472
 
/**
2473
 
 * decodes a slice header.
2474
 
 * This will also call MPV_common_init() and frame_start() as needed.
2475
 
 *
2476
 
 * @param h h264context
2477
 
 * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
2478
 
 *
2479
 
 * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
2480
 
 */
2481
 
static int decode_slice_header(H264Context *h, H264Context *h0){
2482
 
    MpegEncContext * const s = &h->s;
2483
 
    MpegEncContext * const s0 = &h0->s;
2484
 
    unsigned int first_mb_in_slice;
2485
 
    unsigned int pps_id;
2486
 
    int num_ref_idx_active_override_flag;
2487
 
    unsigned int slice_type, tmp, i, j;
2488
 
    int default_ref_list_done = 0;
2489
 
    int last_pic_structure;
2490
 
 
2491
 
    s->dropable= h->nal_ref_idc == 0;
2492
 
 
2493
 
    /* FIXME: 2tap qpel isn't implemented for high bit depth. */
2494
 
    if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc && !h->pixel_shift){
2495
 
        s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
2496
 
        s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
2497
 
    }else{
2498
 
        s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
2499
 
        s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
2500
 
    }
2501
 
 
2502
 
    first_mb_in_slice= get_ue_golomb(&s->gb);
2503
 
 
2504
 
    if(first_mb_in_slice == 0){ //FIXME better field boundary detection
2505
 
        if(h0->current_slice && FIELD_PICTURE){
2506
 
            field_end(h, 1);
2507
 
        }
2508
 
 
2509
 
        h0->current_slice = 0;
2510
 
        if (!s0->first_field)
2511
 
            s->current_picture_ptr= NULL;
2512
 
    }
2513
 
 
2514
 
    slice_type= get_ue_golomb_31(&s->gb);
2515
 
    if(slice_type > 9){
2516
 
        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);
2517
 
        return -1;
2518
 
    }
2519
 
    if(slice_type > 4){
2520
 
        slice_type -= 5;
2521
 
        h->slice_type_fixed=1;
2522
 
    }else
2523
 
        h->slice_type_fixed=0;
2524
 
 
2525
 
    slice_type= golomb_to_pict_type[ slice_type ];
2526
 
    if (slice_type == AV_PICTURE_TYPE_I
2527
 
        || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
2528
 
        default_ref_list_done = 1;
2529
 
    }
2530
 
    h->slice_type= slice_type;
2531
 
    h->slice_type_nos= slice_type & 3;
2532
 
 
2533
 
    s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
2534
 
 
2535
 
    pps_id= get_ue_golomb(&s->gb);
2536
 
    if(pps_id>=MAX_PPS_COUNT){
2537
 
        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
2538
 
        return -1;
2539
 
    }
2540
 
    if(!h0->pps_buffers[pps_id]) {
2541
 
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id);
2542
 
        return -1;
2543
 
    }
2544
 
    h->pps= *h0->pps_buffers[pps_id];
2545
 
 
2546
 
    if(!h0->sps_buffers[h->pps.sps_id]) {
2547
 
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS %u referenced\n", h->pps.sps_id);
2548
 
        return -1;
2549
 
    }
2550
 
    h->sps = *h0->sps_buffers[h->pps.sps_id];
2551
 
 
2552
 
    s->avctx->profile = ff_h264_get_profile(&h->sps);
2553
 
    s->avctx->level   = h->sps.level_idc;
2554
 
    s->avctx->refs    = h->sps.ref_frame_count;
2555
 
 
2556
 
    if(h == h0 && h->dequant_coeff_pps != pps_id){
2557
 
        h->dequant_coeff_pps = pps_id;
2558
 
        init_dequant_tables(h);
2559
 
    }
2560
 
 
2561
 
    s->mb_width= h->sps.mb_width;
2562
 
    s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
2563
 
 
2564
 
    h->b_stride=  s->mb_width*4;
2565
 
 
2566
 
    s->width = 16*s->mb_width - (2>>CHROMA444)*FFMIN(h->sps.crop_right, (8<<CHROMA444)-1);
2567
 
    if(h->sps.frame_mbs_only_flag)
2568
 
        s->height= 16*s->mb_height - (2>>CHROMA444)*FFMIN(h->sps.crop_bottom, (8<<CHROMA444)-1);
2569
 
    else
2570
 
        s->height= 16*s->mb_height - (4>>CHROMA444)*FFMIN(h->sps.crop_bottom, (8<<CHROMA444)-1);
2571
 
 
2572
 
    if (s->context_initialized
2573
 
        && (   s->width != s->avctx->width || s->height != s->avctx->height
2574
 
            || av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {
2575
 
        if(h != h0) {
2576
 
            av_log_missing_feature(s->avctx, "Width/height changing with threads is", 0);
2577
 
            return -1;   // width / height changed during parallelized decoding
2578
 
        }
2579
 
        free_tables(h, 0);
2580
 
        flush_dpb(s->avctx);
2581
 
        MPV_common_end(s);
2582
 
    }
2583
 
    if (!s->context_initialized) {
2584
 
        if (h != h0) {
2585
 
            av_log(h->s.avctx, AV_LOG_ERROR, "Cannot (re-)initialize context during parallel decoding.\n");
2586
 
            return -1;
2587
 
        }
2588
 
 
2589
 
        avcodec_set_dimensions(s->avctx, s->width, s->height);
2590
 
        s->avctx->sample_aspect_ratio= h->sps.sar;
2591
 
        av_assert0(s->avctx->sample_aspect_ratio.den);
2592
 
 
2593
 
        h->s.avctx->coded_width = 16*s->mb_width;
2594
 
        h->s.avctx->coded_height = 16*s->mb_height;
2595
 
 
2596
 
        if(h->sps.video_signal_type_present_flag){
2597
 
            s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
2598
 
            if(h->sps.colour_description_present_flag){
2599
 
                s->avctx->color_primaries = h->sps.color_primaries;
2600
 
                s->avctx->color_trc       = h->sps.color_trc;
2601
 
                s->avctx->colorspace      = h->sps.colorspace;
2602
 
            }
2603
 
        }
2604
 
 
2605
 
        if(h->sps.timing_info_present_flag){
2606
 
            int64_t den= h->sps.time_scale;
2607
 
            if(h->x264_build < 44U)
2608
 
                den *= 2;
2609
 
            av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
2610
 
                      h->sps.num_units_in_tick, den, 1<<30);
2611
 
        }
2612
 
 
2613
 
        switch (h->sps.bit_depth_luma) {
2614
 
            case 9 :
2615
 
                s->avctx->pix_fmt = CHROMA444 ? PIX_FMT_YUV444P9 : PIX_FMT_YUV420P9;
2616
 
                break;
2617
 
            case 10 :
2618
 
                s->avctx->pix_fmt = CHROMA444 ? PIX_FMT_YUV444P10 : PIX_FMT_YUV420P10;
2619
 
                break;
2620
 
            default:
2621
 
                if (CHROMA444){
2622
 
                    s->avctx->pix_fmt = s->avctx->color_range == AVCOL_RANGE_JPEG ? PIX_FMT_YUVJ444P : PIX_FMT_YUV444P;
2623
 
                }else{
2624
 
                    s->avctx->pix_fmt = s->avctx->get_format(s->avctx,
2625
 
                                                             s->avctx->codec->pix_fmts ?
2626
 
                                                             s->avctx->codec->pix_fmts :
2627
 
                                                             s->avctx->color_range == AVCOL_RANGE_JPEG ?
2628
 
                                                             hwaccel_pixfmt_list_h264_jpeg_420 :
2629
 
                                                             ff_hwaccel_pixfmt_list_420);
2630
 
                }
2631
 
        }
2632
 
 
2633
 
        s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
2634
 
 
2635
 
        if (MPV_common_init(s) < 0) {
2636
 
            av_log(h->s.avctx, AV_LOG_ERROR, "MPV_common_init() failed.\n");
2637
 
            return -1;
2638
 
        }
2639
 
        s->first_field = 0;
2640
 
        h->prev_interlaced_frame = 1;
2641
 
 
2642
 
        init_scan_tables(h);
2643
 
        if (ff_h264_alloc_tables(h) < 0) {
2644
 
            av_log(h->s.avctx, AV_LOG_ERROR, "Could not allocate memory for h264\n");
2645
 
            return AVERROR(ENOMEM);
2646
 
        }
2647
 
 
2648
 
        if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {
2649
 
            if (context_init(h) < 0) {
2650
 
                av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
2651
 
                return -1;
2652
 
            }
2653
 
        } else {
2654
 
            for(i = 1; i < s->avctx->thread_count; i++) {
2655
 
                H264Context *c;
2656
 
                c = h->thread_context[i] = av_malloc(sizeof(H264Context));
2657
 
                memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
2658
 
                memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
2659
 
                c->h264dsp = h->h264dsp;
2660
 
                c->sps = h->sps;
2661
 
                c->pps = h->pps;
2662
 
                c->pixel_shift = h->pixel_shift;
2663
 
                init_scan_tables(c);
2664
 
                clone_tables(c, h, i);
2665
 
            }
2666
 
 
2667
 
            for(i = 0; i < s->avctx->thread_count; i++)
2668
 
                if (context_init(h->thread_context[i]) < 0) {
2669
 
                    av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
2670
 
                    return -1;
2671
 
                }
2672
 
        }
2673
 
    }
2674
 
 
2675
 
    h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
2676
 
 
2677
 
    h->mb_mbaff = 0;
2678
 
    h->mb_aff_frame = 0;
2679
 
    last_pic_structure = s0->picture_structure;
2680
 
    if(h->sps.frame_mbs_only_flag){
2681
 
        s->picture_structure= PICT_FRAME;
2682
 
    }else{
2683
 
        if(get_bits1(&s->gb)) { //field_pic_flag
2684
 
            s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
2685
 
        } else {
2686
 
            s->picture_structure= PICT_FRAME;
2687
 
            h->mb_aff_frame = h->sps.mb_aff;
2688
 
        }
2689
 
    }
2690
 
    h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
2691
 
 
2692
 
    if(h0->current_slice == 0){
2693
 
        // Shorten frame num gaps so we don't have to allocate reference frames just to throw them away
2694
 
        if(h->frame_num != h->prev_frame_num) {
2695
 
            int unwrap_prev_frame_num = h->prev_frame_num, max_frame_num = 1<<h->sps.log2_max_frame_num;
2696
 
 
2697
 
            if (unwrap_prev_frame_num > h->frame_num) unwrap_prev_frame_num -= max_frame_num;
2698
 
 
2699
 
            if ((h->frame_num - unwrap_prev_frame_num) > h->sps.ref_frame_count) {
2700
 
                unwrap_prev_frame_num = (h->frame_num - h->sps.ref_frame_count) - 1;
2701
 
                if (unwrap_prev_frame_num < 0)
2702
 
                    unwrap_prev_frame_num += max_frame_num;
2703
 
 
2704
 
                h->prev_frame_num = unwrap_prev_frame_num;
2705
 
            }
2706
 
        }
2707
 
 
2708
 
        while(h->frame_num !=  h->prev_frame_num &&
2709
 
              h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
2710
 
            Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
2711
 
            av_log(h->s.avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num);
2712
 
            if (ff_h264_frame_start(h) < 0)
2713
 
                return -1;
2714
 
            h->prev_frame_num++;
2715
 
            h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
2716
 
            s->current_picture_ptr->frame_num= h->prev_frame_num;
2717
 
            ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);
2718
 
            ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);
2719
 
            ff_generate_sliding_window_mmcos(h);
2720
 
            ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
2721
 
            /* Error concealment: if a ref is missing, copy the previous ref in its place.
2722
 
             * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
2723
 
             * about there being no actual duplicates.
2724
 
             * FIXME: this doesn't copy padding for out-of-frame motion vectors.  Given we're
2725
 
             * concealing a lost frame, this probably isn't noticable by comparison, but it should
2726
 
             * be fixed. */
2727
 
            if (h->short_ref_count) {
2728
 
                if (prev) {
2729
 
                    av_image_copy(h->short_ref[0]->data, h->short_ref[0]->linesize,
2730
 
                                  (const uint8_t**)prev->data, prev->linesize,
2731
 
                                  s->avctx->pix_fmt, s->mb_width*16, s->mb_height*16);
2732
 
                    h->short_ref[0]->poc = prev->poc+2;
2733
 
                }
2734
 
                h->short_ref[0]->frame_num = h->prev_frame_num;
2735
 
            }
2736
 
        }
2737
 
 
2738
 
        /* See if we have a decoded first field looking for a pair... */
2739
 
        if (s0->first_field) {
2740
 
            assert(s0->current_picture_ptr);
2741
 
            assert(s0->current_picture_ptr->data[0]);
2742
 
            assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);
2743
 
 
2744
 
            /* figure out if we have a complementary field pair */
2745
 
            if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {
2746
 
                /*
2747
 
                 * Previous field is unmatched. Don't display it, but let it
2748
 
                 * remain for reference if marked as such.
2749
 
                 */
2750
 
                s0->current_picture_ptr = NULL;
2751
 
                s0->first_field = FIELD_PICTURE;
2752
 
 
2753
 
            } else {
2754
 
                if (h->nal_ref_idc &&
2755
 
                        s0->current_picture_ptr->reference &&
2756
 
                        s0->current_picture_ptr->frame_num != h->frame_num) {
2757
 
                    /*
2758
 
                     * This and previous field were reference, but had
2759
 
                     * different frame_nums. Consider this field first in
2760
 
                     * pair. Throw away previous field except for reference
2761
 
                     * purposes.
2762
 
                     */
2763
 
                    s0->first_field = 1;
2764
 
                    s0->current_picture_ptr = NULL;
2765
 
 
2766
 
                } else {
2767
 
                    /* Second field in complementary pair */
2768
 
                    s0->first_field = 0;
2769
 
                }
2770
 
            }
2771
 
 
2772
 
        } else {
2773
 
            /* Frame or first field in a potentially complementary pair */
2774
 
            assert(!s0->current_picture_ptr);
2775
 
            s0->first_field = FIELD_PICTURE;
2776
 
        }
2777
 
 
2778
 
        if(!FIELD_PICTURE || s0->first_field) {
2779
 
            if (ff_h264_frame_start(h) < 0) {
2780
 
                s0->first_field = 0;
2781
 
                return -1;
2782
 
            }
2783
 
        } else {
2784
 
            ff_release_unused_pictures(s, 0);
2785
 
        }
2786
 
    }
2787
 
    if(h != h0)
2788
 
        clone_slice(h, h0);
2789
 
 
2790
 
    s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup
2791
 
 
2792
 
    assert(s->mb_num == s->mb_width * s->mb_height);
2793
 
    if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||
2794
 
       first_mb_in_slice                    >= s->mb_num){
2795
 
        av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
2796
 
        return -1;
2797
 
    }
2798
 
    s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
2799
 
    s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;
2800
 
    if (s->picture_structure == PICT_BOTTOM_FIELD)
2801
 
        s->resync_mb_y = s->mb_y = s->mb_y + 1;
2802
 
    assert(s->mb_y < s->mb_height);
2803
 
 
2804
 
    if(s->picture_structure==PICT_FRAME){
2805
 
        h->curr_pic_num=   h->frame_num;
2806
 
        h->max_pic_num= 1<< h->sps.log2_max_frame_num;
2807
 
    }else{
2808
 
        h->curr_pic_num= 2*h->frame_num + 1;
2809
 
        h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
2810
 
    }
2811
 
 
2812
 
    if(h->nal_unit_type == NAL_IDR_SLICE){
2813
 
        get_ue_golomb(&s->gb); /* idr_pic_id */
2814
 
    }
2815
 
 
2816
 
    if(h->sps.poc_type==0){
2817
 
        h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
2818
 
 
2819
 
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
2820
 
            h->delta_poc_bottom= get_se_golomb(&s->gb);
2821
 
        }
2822
 
    }
2823
 
 
2824
 
    if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
2825
 
        h->delta_poc[0]= get_se_golomb(&s->gb);
2826
 
 
2827
 
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
2828
 
            h->delta_poc[1]= get_se_golomb(&s->gb);
2829
 
    }
2830
 
 
2831
 
    init_poc(h);
2832
 
 
2833
 
    if(h->pps.redundant_pic_cnt_present){
2834
 
        h->redundant_pic_count= get_ue_golomb(&s->gb);
2835
 
    }
2836
 
 
2837
 
    //set defaults, might be overridden a few lines later
2838
 
    h->ref_count[0]= h->pps.ref_count[0];
2839
 
    h->ref_count[1]= h->pps.ref_count[1];
2840
 
 
2841
 
    if(h->slice_type_nos != AV_PICTURE_TYPE_I){
2842
 
        if(h->slice_type_nos == AV_PICTURE_TYPE_B){
2843
 
            h->direct_spatial_mv_pred= get_bits1(&s->gb);
2844
 
        }
2845
 
        num_ref_idx_active_override_flag= get_bits1(&s->gb);
2846
 
 
2847
 
        if(num_ref_idx_active_override_flag){
2848
 
            h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
2849
 
            if(h->slice_type_nos==AV_PICTURE_TYPE_B)
2850
 
                h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
2851
 
 
2852
 
            if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
2853
 
                av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
2854
 
                h->ref_count[0]= h->ref_count[1]= 1;
2855
 
                return -1;
2856
 
            }
2857
 
        }
2858
 
        if(h->slice_type_nos == AV_PICTURE_TYPE_B)
2859
 
            h->list_count= 2;
2860
 
        else
2861
 
            h->list_count= 1;
2862
 
    }else
2863
 
        h->list_count= 0;
2864
 
 
2865
 
    if(!default_ref_list_done){
2866
 
        ff_h264_fill_default_ref_list(h);
2867
 
    }
2868
 
 
2869
 
    if(h->slice_type_nos!=AV_PICTURE_TYPE_I && ff_h264_decode_ref_pic_list_reordering(h) < 0)
2870
 
        return -1;
2871
 
 
2872
 
    if(h->slice_type_nos!=AV_PICTURE_TYPE_I){
2873
 
        s->last_picture_ptr= &h->ref_list[0][0];
2874
 
        ff_copy_picture(&s->last_picture, s->last_picture_ptr);
2875
 
    }
2876
 
    if(h->slice_type_nos==AV_PICTURE_TYPE_B){
2877
 
        s->next_picture_ptr= &h->ref_list[1][0];
2878
 
        ff_copy_picture(&s->next_picture, s->next_picture_ptr);
2879
 
    }
2880
 
 
2881
 
    if(   (h->pps.weighted_pred          && h->slice_type_nos == AV_PICTURE_TYPE_P )
2882
 
       ||  (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== AV_PICTURE_TYPE_B ) )
2883
 
        pred_weight_table(h);
2884
 
    else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== AV_PICTURE_TYPE_B){
2885
 
        implicit_weight_table(h, -1);
2886
 
    }else {
2887
 
        h->use_weight = 0;
2888
 
        for (i = 0; i < 2; i++) {
2889
 
            h->luma_weight_flag[i]   = 0;
2890
 
            h->chroma_weight_flag[i] = 0;
2891
 
        }
2892
 
    }
2893
 
 
2894
 
    if(h->nal_ref_idc)
2895
 
        ff_h264_decode_ref_pic_marking(h0, &s->gb);
2896
 
 
2897
 
    if(FRAME_MBAFF){
2898
 
        ff_h264_fill_mbaff_ref_list(h);
2899
 
 
2900
 
        if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== AV_PICTURE_TYPE_B){
2901
 
            implicit_weight_table(h, 0);
2902
 
            implicit_weight_table(h, 1);
2903
 
        }
2904
 
    }
2905
 
 
2906
 
    if(h->slice_type_nos==AV_PICTURE_TYPE_B && !h->direct_spatial_mv_pred)
2907
 
        ff_h264_direct_dist_scale_factor(h);
2908
 
    ff_h264_direct_ref_list_init(h);
2909
 
 
2910
 
    if( h->slice_type_nos != AV_PICTURE_TYPE_I && h->pps.cabac ){
2911
 
        tmp = get_ue_golomb_31(&s->gb);
2912
 
        if(tmp > 2){
2913
 
            av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
2914
 
            return -1;
2915
 
        }
2916
 
        h->cabac_init_idc= tmp;
2917
 
    }
2918
 
 
2919
 
    h->last_qscale_diff = 0;
2920
 
    tmp = h->pps.init_qp + get_se_golomb(&s->gb);
2921
 
    if(tmp>51+6*(h->sps.bit_depth_luma-8)){
2922
 
        av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
2923
 
        return -1;
2924
 
    }
2925
 
    s->qscale= tmp;
2926
 
    h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2927
 
    h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
2928
 
    //FIXME qscale / qp ... stuff
2929
 
    if(h->slice_type == AV_PICTURE_TYPE_SP){
2930
 
        get_bits1(&s->gb); /* sp_for_switch_flag */
2931
 
    }
2932
 
    if(h->slice_type==AV_PICTURE_TYPE_SP || h->slice_type == AV_PICTURE_TYPE_SI){
2933
 
        get_se_golomb(&s->gb); /* slice_qs_delta */
2934
 
    }
2935
 
 
2936
 
    h->deblocking_filter = 1;
2937
 
    h->slice_alpha_c0_offset = 52;
2938
 
    h->slice_beta_offset = 52;
2939
 
    if( h->pps.deblocking_filter_parameters_present ) {
2940
 
        tmp= get_ue_golomb_31(&s->gb);
2941
 
        if(tmp > 2){
2942
 
            av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
2943
 
            return -1;
2944
 
        }
2945
 
        h->deblocking_filter= tmp;
2946
 
        if(h->deblocking_filter < 2)
2947
 
            h->deblocking_filter^= 1; // 1<->0
2948
 
 
2949
 
        if( h->deblocking_filter ) {
2950
 
            h->slice_alpha_c0_offset += get_se_golomb(&s->gb) << 1;
2951
 
            h->slice_beta_offset     += get_se_golomb(&s->gb) << 1;
2952
 
            if(   h->slice_alpha_c0_offset > 104U
2953
 
               || h->slice_beta_offset     > 104U){
2954
 
                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);
2955
 
                return -1;
2956
 
            }
2957
 
        }
2958
 
    }
2959
 
 
2960
 
    if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
2961
 
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != AV_PICTURE_TYPE_I)
2962
 
       ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type_nos == AV_PICTURE_TYPE_B)
2963
 
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
2964
 
        h->deblocking_filter= 0;
2965
 
 
2966
 
    if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
2967
 
        if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
2968
 
            /* Cheat slightly for speed:
2969
 
               Do not bother to deblock across slices. */
2970
 
            h->deblocking_filter = 2;
2971
 
        } else {
2972
 
            h0->max_contexts = 1;
2973
 
            if(!h0->single_decode_warning) {
2974
 
                av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
2975
 
                h0->single_decode_warning = 1;
2976
 
            }
2977
 
            if (h != h0) {
2978
 
                av_log(h->s.avctx, AV_LOG_ERROR, "Deblocking switched inside frame.\n");
2979
 
                return 1;
2980
 
            }
2981
 
        }
2982
 
    }
2983
 
    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]);
2984
 
 
2985
 
#if 0 //FMO
2986
 
    if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
2987
 
        slice_group_change_cycle= get_bits(&s->gb, ?);
2988
 
#endif
2989
 
 
2990
 
    h0->last_slice_type = slice_type;
2991
 
    h->slice_num = ++h0->current_slice;
2992
 
    if(h->slice_num >= MAX_SLICES){
2993
 
        av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
2994
 
    }
2995
 
 
2996
 
    for(j=0; j<2; j++){
2997
 
        int id_list[16];
2998
 
        int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
2999
 
        for(i=0; i<16; i++){
3000
 
            id_list[i]= 60;
3001
 
            if(h->ref_list[j][i].data[0]){
3002
 
                int k;
3003
 
                uint8_t *base= h->ref_list[j][i].base[0];
3004
 
                for(k=0; k<h->short_ref_count; k++)
3005
 
                    if(h->short_ref[k]->base[0] == base){
3006
 
                        id_list[i]= k;
3007
 
                        break;
3008
 
                    }
3009
 
                for(k=0; k<h->long_ref_count; k++)
3010
 
                    if(h->long_ref[k] && h->long_ref[k]->base[0] == base){
3011
 
                        id_list[i]= h->short_ref_count + k;
3012
 
                        break;
3013
 
                    }
3014
 
            }
3015
 
        }
3016
 
 
3017
 
        ref2frm[0]=
3018
 
        ref2frm[1]= -1;
3019
 
        for(i=0; i<16; i++)
3020
 
            ref2frm[i+2]= 4*id_list[i]
3021
 
                          +(h->ref_list[j][i].reference&3);
3022
 
        ref2frm[18+0]=
3023
 
        ref2frm[18+1]= -1;
3024
 
        for(i=16; i<48; i++)
3025
 
            ref2frm[i+4]= 4*id_list[(i-16)>>1]
3026
 
                          +(h->ref_list[j][i].reference&3);
3027
 
    }
3028
 
 
3029
 
    //FIXME: fix draw_edges+PAFF+frame threads
3030
 
    h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE || (!h->sps.frame_mbs_only_flag && s->avctx->active_thread_type)) ? 0 : 16;
3031
 
    h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
3032
 
 
3033
 
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
3034
 
        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",
3035
 
               h->slice_num,
3036
 
               (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
3037
 
               first_mb_in_slice,
3038
 
               av_get_picture_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
3039
 
               pps_id, h->frame_num,
3040
 
               s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
3041
 
               h->ref_count[0], h->ref_count[1],
3042
 
               s->qscale,
3043
 
               h->deblocking_filter, h->slice_alpha_c0_offset/2-26, h->slice_beta_offset/2-26,
3044
 
               h->use_weight,
3045
 
               h->use_weight==1 && h->use_weight_chroma ? "c" : "",
3046
 
               h->slice_type == AV_PICTURE_TYPE_B ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""
3047
 
               );
3048
 
    }
3049
 
 
3050
 
    return 0;
3051
 
}
3052
 
 
3053
 
int ff_h264_get_slice_type(const H264Context *h)
3054
 
{
3055
 
    switch (h->slice_type) {
3056
 
    case AV_PICTURE_TYPE_P:  return 0;
3057
 
    case AV_PICTURE_TYPE_B:  return 1;
3058
 
    case AV_PICTURE_TYPE_I:  return 2;
3059
 
    case AV_PICTURE_TYPE_SP: return 3;
3060
 
    case AV_PICTURE_TYPE_SI: return 4;
3061
 
    default:         return -1;
3062
 
    }
3063
 
}
3064
 
 
3065
 
/**
3066
 
 *
3067
 
 * @return non zero if the loop filter can be skiped
3068
 
 */
3069
 
static int fill_filter_caches(H264Context *h, int mb_type){
3070
 
    MpegEncContext * const s = &h->s;
3071
 
    const int mb_xy= h->mb_xy;
3072
 
    int top_xy, left_xy[2];
3073
 
    int top_type, left_type[2];
3074
 
 
3075
 
    top_xy     = mb_xy  - (s->mb_stride << MB_FIELD);
3076
 
 
3077
 
    //FIXME deblocking could skip the intra and nnz parts.
3078
 
 
3079
 
    /* Wow, what a mess, why didn't they simplify the interlacing & intra
3080
 
     * stuff, I can't imagine that these complex rules are worth it. */
3081
 
 
3082
 
    left_xy[1] = left_xy[0] = mb_xy-1;
3083
 
    if(FRAME_MBAFF){
3084
 
        const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
3085
 
        const int curr_mb_field_flag     = IS_INTERLACED(mb_type);
3086
 
        if(s->mb_y&1){
3087
 
            if (left_mb_field_flag != curr_mb_field_flag) {
3088
 
                left_xy[0] -= s->mb_stride;
3089
 
            }
3090
 
        }else{
3091
 
            if(curr_mb_field_flag){
3092
 
                top_xy      += s->mb_stride & (((s->current_picture.mb_type[top_xy    ]>>7)&1)-1);
3093
 
            }
3094
 
            if (left_mb_field_flag != curr_mb_field_flag) {
3095
 
                left_xy[1] += s->mb_stride;
3096
 
            }
3097
 
        }
3098
 
    }
3099
 
 
3100
 
    h->top_mb_xy = top_xy;
3101
 
    h->left_mb_xy[0] = left_xy[0];
3102
 
    h->left_mb_xy[1] = left_xy[1];
3103
 
    {
3104
 
        //for sufficiently low qp, filtering wouldn't do anything
3105
 
        //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
3106
 
        int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
3107
 
        int qp = s->current_picture.qscale_table[mb_xy];
3108
 
        if(qp <= qp_thresh
3109
 
           && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
3110
 
           && (top_xy   < 0 || ((qp + s->current_picture.qscale_table[top_xy    ] + 1)>>1) <= qp_thresh)){
3111
 
            if(!FRAME_MBAFF)
3112
 
                return 1;
3113
 
            if(   (left_xy[0]< 0            || ((qp + s->current_picture.qscale_table[left_xy[1]             ] + 1)>>1) <= qp_thresh)
3114
 
               && (top_xy    < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy    -s->mb_stride] + 1)>>1) <= qp_thresh))
3115
 
                return 1;
3116
 
        }
3117
 
    }
3118
 
 
3119
 
    top_type     = s->current_picture.mb_type[top_xy]    ;
3120
 
    left_type[0] = s->current_picture.mb_type[left_xy[0]];
3121
 
    left_type[1] = s->current_picture.mb_type[left_xy[1]];
3122
 
    if(h->deblocking_filter == 2){
3123
 
        if(h->slice_table[top_xy     ] != h->slice_num) top_type= 0;
3124
 
        if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;
3125
 
    }else{
3126
 
        if(h->slice_table[top_xy     ] == 0xFFFF) top_type= 0;
3127
 
        if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;
3128
 
    }
3129
 
    h->top_type    = top_type    ;
3130
 
    h->left_type[0]= left_type[0];
3131
 
    h->left_type[1]= left_type[1];
3132
 
 
3133
 
    if(IS_INTRA(mb_type))
3134
 
        return 0;
3135
 
 
3136
 
    AV_COPY32(&h->non_zero_count_cache[4+8* 1], &h->non_zero_count[mb_xy][ 0]);
3137
 
    AV_COPY32(&h->non_zero_count_cache[4+8* 2], &h->non_zero_count[mb_xy][ 4]);
3138
 
    AV_COPY32(&h->non_zero_count_cache[4+8* 3], &h->non_zero_count[mb_xy][ 8]);
3139
 
    AV_COPY32(&h->non_zero_count_cache[4+8* 4], &h->non_zero_count[mb_xy][12]);
3140
 
 
3141
 
    h->cbp= h->cbp_table[mb_xy];
3142
 
 
3143
 
    {
3144
 
        int list;
3145
 
        for(list=0; list<h->list_count; list++){
3146
 
            int8_t *ref;
3147
 
            int y, b_stride;
3148
 
            int16_t (*mv_dst)[2];
3149
 
            int16_t (*mv_src)[2];
3150
 
 
3151
 
            if(!USES_LIST(mb_type, list)){
3152
 
                fill_rectangle(  h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
3153
 
                AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
3154
 
                AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
3155
 
                AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
3156
 
                AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
3157
 
                continue;
3158
 
            }
3159
 
 
3160
 
            ref = &s->current_picture.ref_index[list][4*mb_xy];
3161
 
            {
3162
 
                int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
3163
 
                AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
3164
 
                AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
3165
 
                ref += 2;
3166
 
                AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
3167
 
                AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
3168
 
            }
3169
 
 
3170
 
            b_stride = h->b_stride;
3171
 
            mv_dst   = &h->mv_cache[list][scan8[0]];
3172
 
            mv_src   = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
3173
 
            for(y=0; y<4; y++){
3174
 
                AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
3175
 
            }
3176
 
 
3177
 
        }
3178
 
    }
3179
 
 
3180
 
 
3181
 
/*
3182
 
0 . T T. T T T T
3183
 
1 L . .L . . . .
3184
 
2 L . .L . . . .
3185
 
3 . T TL . . . .
3186
 
4 L . .L . . . .
3187
 
5 L . .. . . . .
3188
 
*/
3189
 
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
3190
 
    if(top_type){
3191
 
        AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][3*4]);
3192
 
    }
3193
 
 
3194
 
    if(left_type[0]){
3195
 
        h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][3+0*4];
3196
 
        h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][3+1*4];
3197
 
        h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][3+2*4];
3198
 
        h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][3+3*4];
3199
 
    }
3200
 
 
3201
 
    // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
3202
 
    if(!CABAC && h->pps.transform_8x8_mode){
3203
 
        if(IS_8x8DCT(top_type)){
3204
 
            h->non_zero_count_cache[4+8*0]=
3205
 
            h->non_zero_count_cache[5+8*0]= (h->cbp_table[top_xy] & 0x4000) >> 12;
3206
 
            h->non_zero_count_cache[6+8*0]=
3207
 
            h->non_zero_count_cache[7+8*0]= (h->cbp_table[top_xy] & 0x8000) >> 12;
3208
 
        }
3209
 
        if(IS_8x8DCT(left_type[0])){
3210
 
            h->non_zero_count_cache[3+8*1]=
3211
 
            h->non_zero_count_cache[3+8*2]= (h->cbp_table[left_xy[0]]&0x2000) >> 12; //FIXME check MBAFF
3212
 
        }
3213
 
        if(IS_8x8DCT(left_type[1])){
3214
 
            h->non_zero_count_cache[3+8*3]=
3215
 
            h->non_zero_count_cache[3+8*4]= (h->cbp_table[left_xy[1]]&0x8000) >> 12; //FIXME check MBAFF
3216
 
        }
3217
 
 
3218
 
        if(IS_8x8DCT(mb_type)){
3219
 
            h->non_zero_count_cache[scan8[0   ]]= h->non_zero_count_cache[scan8[1   ]]=
3220
 
            h->non_zero_count_cache[scan8[2   ]]= h->non_zero_count_cache[scan8[3   ]]= (h->cbp & 0x1000) >> 12;
3221
 
 
3222
 
            h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
3223
 
            h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= (h->cbp & 0x2000) >> 12;
3224
 
 
3225
 
            h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
3226
 
            h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= (h->cbp & 0x4000) >> 12;
3227
 
 
3228
 
            h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
3229
 
            h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= (h->cbp & 0x8000) >> 12;
3230
 
        }
3231
 
    }
3232
 
 
3233
 
    if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
3234
 
        int list;
3235
 
        for(list=0; list<h->list_count; list++){
3236
 
            if(USES_LIST(top_type, list)){
3237
 
                const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
3238
 
                const int b8_xy= 4*top_xy + 2;
3239
 
                int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
3240
 
                AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
3241
 
                h->ref_cache[list][scan8[0] + 0 - 1*8]=
3242
 
                h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
3243
 
                h->ref_cache[list][scan8[0] + 2 - 1*8]=
3244
 
                h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
3245
 
            }else{
3246
 
                AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
3247
 
                AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
3248
 
            }
3249
 
 
3250
 
            if(!IS_INTERLACED(mb_type^left_type[0])){
3251
 
                if(USES_LIST(left_type[0], list)){
3252
 
                    const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
3253
 
                    const int b8_xy= 4*left_xy[0] + 1;
3254
 
                    int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
3255
 
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);
3256
 
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);
3257
 
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);
3258
 
                    AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);
3259
 
                    h->ref_cache[list][scan8[0] - 1 + 0 ]=
3260
 
                    h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];
3261
 
                    h->ref_cache[list][scan8[0] - 1 +16 ]=
3262
 
                    h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];
3263
 
                }else{
3264
 
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);
3265
 
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);
3266
 
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);
3267
 
                    AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);
3268
 
                    h->ref_cache[list][scan8[0] - 1 + 0  ]=
3269
 
                    h->ref_cache[list][scan8[0] - 1 + 8  ]=
3270
 
                    h->ref_cache[list][scan8[0] - 1 + 16 ]=
3271
 
                    h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
3272
 
                }
3273
 
            }
3274
 
        }
3275
 
    }
3276
 
 
3277
 
    return 0;
3278
 
}
3279
 
 
3280
 
static void loop_filter(H264Context *h, int start_x, int end_x){
3281
 
    MpegEncContext * const s = &h->s;
3282
 
    uint8_t  *dest_y, *dest_cb, *dest_cr;
3283
 
    int linesize, uvlinesize, mb_x, mb_y;
3284
 
    const int end_mb_y= s->mb_y + FRAME_MBAFF;
3285
 
    const int old_slice_type= h->slice_type;
3286
 
    const int pixel_shift = h->pixel_shift;
3287
 
 
3288
 
    if(h->deblocking_filter) {
3289
 
        for(mb_x= start_x; mb_x<end_x; mb_x++){
3290
 
            for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){
3291
 
                int mb_xy, mb_type;
3292
 
                mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;
3293
 
                h->slice_num= h->slice_table[mb_xy];
3294
 
                mb_type= s->current_picture.mb_type[mb_xy];
3295
 
                h->list_count= h->list_counts[mb_xy];
3296
 
 
3297
 
                if(FRAME_MBAFF)
3298
 
                    h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
3299
 
 
3300
 
                s->mb_x= mb_x;
3301
 
                s->mb_y= mb_y;
3302
 
                dest_y  = s->current_picture.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize  ) * 16;
3303
 
                dest_cb = s->current_picture.data[1] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * (8 << CHROMA444);
3304
 
                dest_cr = s->current_picture.data[2] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * (8 << CHROMA444);
3305
 
                    //FIXME simplify above
3306
 
 
3307
 
                if (MB_FIELD) {
3308
 
                    linesize   = h->mb_linesize   = s->linesize * 2;
3309
 
                    uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
3310
 
                    if(mb_y&1){ //FIXME move out of this function?
3311
 
                        dest_y -= s->linesize*15;
3312
 
                        dest_cb-= s->uvlinesize*((8 << CHROMA444)-1);
3313
 
                        dest_cr-= s->uvlinesize*((8 << CHROMA444)-1);
3314
 
                    }
3315
 
                } else {
3316
 
                    linesize   = h->mb_linesize   = s->linesize;
3317
 
                    uvlinesize = h->mb_uvlinesize = s->uvlinesize;
3318
 
                }
3319
 
                backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, CHROMA444, 0);
3320
 
                if(fill_filter_caches(h, mb_type))
3321
 
                    continue;
3322
 
                h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
3323
 
                h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
3324
 
 
3325
 
                if (FRAME_MBAFF) {
3326
 
                    ff_h264_filter_mb     (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3327
 
                } else {
3328
 
                    ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3329
 
                }
3330
 
            }
3331
 
        }
3332
 
    }
3333
 
    h->slice_type= old_slice_type;
3334
 
    s->mb_x= end_x;
3335
 
    s->mb_y= end_mb_y - FRAME_MBAFF;
3336
 
    h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
3337
 
    h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
3338
 
}
3339
 
 
3340
 
static void predict_field_decoding_flag(H264Context *h){
3341
 
    MpegEncContext * const s = &h->s;
3342
 
    const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
3343
 
    int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
3344
 
                ? s->current_picture.mb_type[mb_xy-1]
3345
 
                : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
3346
 
                ? s->current_picture.mb_type[mb_xy-s->mb_stride]
3347
 
                : 0;
3348
 
    h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
3349
 
}
3350
 
 
3351
 
/**
3352
 
 * Draw edges and report progress for the last MB row.
3353
 
 */
3354
 
static void decode_finish_row(H264Context *h){
3355
 
    MpegEncContext * const s = &h->s;
3356
 
    int top = 16*(s->mb_y >> FIELD_PICTURE);
3357
 
    int height = 16 << FRAME_MBAFF;
3358
 
    int deblock_border = (16 + 4) << FRAME_MBAFF;
3359
 
    int pic_height = 16*s->mb_height >> FIELD_PICTURE;
3360
 
 
3361
 
    if (h->deblocking_filter) {
3362
 
        if((top + height) >= pic_height)
3363
 
            height += deblock_border;
3364
 
 
3365
 
        top -= deblock_border;
3366
 
    }
3367
 
 
3368
 
    if (top >= pic_height || (top + height) < h->emu_edge_height)
3369
 
        return;
3370
 
 
3371
 
    height = FFMIN(height, pic_height - top);
3372
 
    if (top < h->emu_edge_height) {
3373
 
        height = top+height;
3374
 
        top = 0;
3375
 
    }
3376
 
 
3377
 
    ff_draw_horiz_band(s, top, height);
3378
 
 
3379
 
    if (s->dropable) return;
3380
 
 
3381
 
    ff_thread_report_progress((AVFrame*)s->current_picture_ptr, top + height - 1,
3382
 
                             s->picture_structure==PICT_BOTTOM_FIELD);
3383
 
}
3384
 
 
3385
 
static int decode_slice(struct AVCodecContext *avctx, void *arg){
3386
 
    H264Context *h = *(void**)arg;
3387
 
    MpegEncContext * const s = &h->s;
3388
 
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
3389
 
    int lf_x_start = s->mb_x;
3390
 
 
3391
 
    s->mb_skip_run= -1;
3392
 
 
3393
 
    h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
3394
 
                    (CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY));
3395
 
 
3396
 
    if( h->pps.cabac ) {
3397
 
        /* realign */
3398
 
        align_get_bits( &s->gb );
3399
 
 
3400
 
        /* init cabac */
3401
 
        ff_init_cabac_states( &h->cabac);
3402
 
        ff_init_cabac_decoder( &h->cabac,
3403
 
                               s->gb.buffer + get_bits_count(&s->gb)/8,
3404
 
                               (get_bits_left(&s->gb) + 7)/8);
3405
 
 
3406
 
        ff_h264_init_cabac_states(h);
3407
 
 
3408
 
        for(;;){
3409
 
//START_TIMER
3410
 
            int ret = ff_h264_decode_mb_cabac(h);
3411
 
            int eos;
3412
 
//STOP_TIMER("decode_mb_cabac")
3413
 
 
3414
 
            if(ret>=0) ff_h264_hl_decode_mb(h);
3415
 
 
3416
 
            if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
3417
 
                s->mb_y++;
3418
 
 
3419
 
                ret = ff_h264_decode_mb_cabac(h);
3420
 
 
3421
 
                if(ret>=0) ff_h264_hl_decode_mb(h);
3422
 
                s->mb_y--;
3423
 
            }
3424
 
            eos = get_cabac_terminate( &h->cabac );
3425
 
 
3426
 
            if((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2){
3427
 
                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);
3428
 
                if (s->mb_x >= lf_x_start) loop_filter(h, lf_x_start, s->mb_x + 1);
3429
 
                return 0;
3430
 
            }
3431
 
            if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
3432
 
                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);
3433
 
                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);
3434
 
                return -1;
3435
 
            }
3436
 
 
3437
 
            if( ++s->mb_x >= s->mb_width ) {
3438
 
                loop_filter(h, lf_x_start, s->mb_x);
3439
 
                s->mb_x = lf_x_start = 0;
3440
 
                decode_finish_row(h);
3441
 
                ++s->mb_y;
3442
 
                if(FIELD_OR_MBAFF_PICTURE) {
3443
 
                    ++s->mb_y;
3444
 
                    if(FRAME_MBAFF && s->mb_y < s->mb_height)
3445
 
                        predict_field_decoding_flag(h);
3446
 
                }
3447
 
            }
3448
 
 
3449
 
            if( eos || s->mb_y >= s->mb_height ) {
3450
 
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
3451
 
                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);
3452
 
                if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x);
3453
 
                return 0;
3454
 
            }
3455
 
        }
3456
 
 
3457
 
    } else {
3458
 
        for(;;){
3459
 
            int ret = ff_h264_decode_mb_cavlc(h);
3460
 
 
3461
 
            if(ret>=0) ff_h264_hl_decode_mb(h);
3462
 
 
3463
 
            if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
3464
 
                s->mb_y++;
3465
 
                ret = ff_h264_decode_mb_cavlc(h);
3466
 
 
3467
 
                if(ret>=0) ff_h264_hl_decode_mb(h);
3468
 
                s->mb_y--;
3469
 
            }
3470
 
 
3471
 
            if(ret<0){
3472
 
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
3473
 
                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);
3474
 
                return -1;
3475
 
            }
3476
 
 
3477
 
            if(++s->mb_x >= s->mb_width){
3478
 
                loop_filter(h, lf_x_start, s->mb_x);
3479
 
                s->mb_x = lf_x_start = 0;
3480
 
                decode_finish_row(h);
3481
 
                ++s->mb_y;
3482
 
                if(FIELD_OR_MBAFF_PICTURE) {
3483
 
                    ++s->mb_y;
3484
 
                    if(FRAME_MBAFF && s->mb_y < s->mb_height)
3485
 
                        predict_field_decoding_flag(h);
3486
 
                }
3487
 
                if(s->mb_y >= s->mb_height){
3488
 
                    tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
3489
 
 
3490
 
                    if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
3491
 
                        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);
3492
 
 
3493
 
                        return 0;
3494
 
                    }else{
3495
 
                        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
3496
 
 
3497
 
                        return -1;
3498
 
                    }
3499
 
                }
3500
 
            }
3501
 
 
3502
 
            if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
3503
 
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
3504
 
                if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
3505
 
                    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);
3506
 
                    if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x);
3507
 
 
3508
 
                    return 0;
3509
 
                }else{
3510
 
                    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);
3511
 
 
3512
 
                    return -1;
3513
 
                }
3514
 
            }
3515
 
        }
3516
 
    }
3517
 
 
3518
 
#if 0
3519
 
    for(;s->mb_y < s->mb_height; s->mb_y++){
3520
 
        for(;s->mb_x < s->mb_width; s->mb_x++){
3521
 
            int ret= decode_mb(h);
3522
 
 
3523
 
            ff_h264_hl_decode_mb(h);
3524
 
 
3525
 
            if(ret<0){
3526
 
                av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
3527
 
                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);
3528
 
 
3529
 
                return -1;
3530
 
            }
3531
 
 
3532
 
            if(++s->mb_x >= s->mb_width){
3533
 
                s->mb_x=0;
3534
 
                if(++s->mb_y >= s->mb_height){
3535
 
                    if(get_bits_count(s->gb) == s->gb.size_in_bits){
3536
 
                        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);
3537
 
 
3538
 
                        return 0;
3539
 
                    }else{
3540
 
                        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
3541
 
 
3542
 
                        return -1;
3543
 
                    }
3544
 
                }
3545
 
            }
3546
 
 
3547
 
            if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
3548
 
                if(get_bits_count(s->gb) == s->gb.size_in_bits){
3549
 
                    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);
3550
 
 
3551
 
                    return 0;
3552
 
                }else{
3553
 
                    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);
3554
 
 
3555
 
                    return -1;
3556
 
                }
3557
 
            }
3558
 
        }
3559
 
        s->mb_x=0;
3560
 
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
3561
 
    }
3562
 
#endif
3563
 
    return -1; //not reached
3564
 
}
3565
 
 
3566
 
/**
3567
 
 * Call decode_slice() for each context.
3568
 
 *
3569
 
 * @param h h264 master context
3570
 
 * @param context_count number of contexts to execute
3571
 
 */
3572
 
static void execute_decode_slices(H264Context *h, int context_count){
3573
 
    MpegEncContext * const s = &h->s;
3574
 
    AVCodecContext * const avctx= s->avctx;
3575
 
    H264Context *hx;
3576
 
    int i;
3577
 
 
3578
 
    if (s->avctx->hwaccel)
3579
 
        return;
3580
 
    if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
3581
 
        return;
3582
 
    if(context_count == 1) {
3583
 
        decode_slice(avctx, &h);
3584
 
    } else {
3585
 
        for(i = 1; i < context_count; i++) {
3586
 
            hx = h->thread_context[i];
3587
 
            hx->s.error_recognition = avctx->error_recognition;
3588
 
            hx->s.error_count = 0;
3589
 
        }
3590
 
 
3591
 
        avctx->execute(avctx, (void *)decode_slice,
3592
 
                       h->thread_context, NULL, context_count, sizeof(void*));
3593
 
 
3594
 
        /* pull back stuff from slices to master context */
3595
 
        hx = h->thread_context[context_count - 1];
3596
 
        s->mb_x = hx->s.mb_x;
3597
 
        s->mb_y = hx->s.mb_y;
3598
 
        s->dropable = hx->s.dropable;
3599
 
        s->picture_structure = hx->s.picture_structure;
3600
 
        for(i = 1; i < context_count; i++)
3601
 
            h->s.error_count += h->thread_context[i]->s.error_count;
3602
 
    }
3603
 
}
3604
 
 
3605
 
 
3606
 
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
3607
 
    MpegEncContext * const s = &h->s;
3608
 
    AVCodecContext * const avctx= s->avctx;
3609
 
    H264Context *hx; ///< thread context
3610
 
    int buf_index;
3611
 
    int context_count;
3612
 
    int next_avc;
3613
 
    int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);
3614
 
    int nals_needed=0; ///< number of NALs that need decoding before the next frame thread starts
3615
 
    int nal_index;
3616
 
 
3617
 
    h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;
3618
 
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
3619
 
        h->current_slice = 0;
3620
 
        if (!s->first_field)
3621
 
            s->current_picture_ptr= NULL;
3622
 
        ff_h264_reset_sei(h);
3623
 
    }
3624
 
 
3625
 
    for(;pass <= 1;pass++){
3626
 
        buf_index = 0;
3627
 
        context_count = 0;
3628
 
        next_avc = h->is_avc ? 0 : buf_size;
3629
 
        nal_index = 0;
3630
 
    for(;;){
3631
 
        int consumed;
3632
 
        int dst_length;
3633
 
        int bit_length;
3634
 
        const uint8_t *ptr;
3635
 
        int i, nalsize = 0;
3636
 
        int err;
3637
 
 
3638
 
        if(buf_index >= next_avc) {
3639
 
            if(buf_index >= buf_size) break;
3640
 
            nalsize = 0;
3641
 
            for(i = 0; i < h->nal_length_size; i++)
3642
 
                nalsize = (nalsize << 8) | buf[buf_index++];
3643
 
            if(nalsize <= 0 || nalsize > buf_size - buf_index){
3644
 
                av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
3645
 
                break;
3646
 
            }
3647
 
            next_avc= buf_index + nalsize;
3648
 
        } else {
3649
 
            // start code prefix search
3650
 
            for(; buf_index + 3 < next_avc; buf_index++){
3651
 
                // This should always succeed in the first iteration.
3652
 
                if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
3653
 
                    break;
3654
 
            }
3655
 
 
3656
 
            if(buf_index+3 >= buf_size) break;
3657
 
 
3658
 
            buf_index+=3;
3659
 
            if(buf_index >= next_avc) continue;
3660
 
        }
3661
 
 
3662
 
        hx = h->thread_context[context_count];
3663
 
 
3664
 
        ptr= ff_h264_decode_nal(hx, buf + buf_index, &dst_length, &consumed, next_avc - buf_index);
3665
 
        if (ptr==NULL || dst_length < 0){
3666
 
            return -1;
3667
 
        }
3668
 
        i= buf_index + consumed;
3669
 
        if((s->workaround_bugs & FF_BUG_AUTODETECT) && i+3<next_avc &&
3670
 
           buf[i]==0x00 && buf[i+1]==0x00 && buf[i+2]==0x01 && buf[i+3]==0xE0)
3671
 
            s->workaround_bugs |= FF_BUG_TRUNCATED;
3672
 
 
3673
 
        if(!(s->workaround_bugs & FF_BUG_TRUNCATED)){
3674
 
        while(ptr[dst_length - 1] == 0 && dst_length > 0)
3675
 
            dst_length--;
3676
 
        }
3677
 
        bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));
3678
 
 
3679
 
        if(s->avctx->debug&FF_DEBUG_STARTCODE){
3680
 
            av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length);
3681
 
        }
3682
 
 
3683
 
        if (h->is_avc && (nalsize != consumed) && nalsize){
3684
 
            av_log(h->s.avctx, AV_LOG_DEBUG, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
3685
 
        }
3686
 
 
3687
 
        buf_index += consumed;
3688
 
        nal_index++;
3689
 
 
3690
 
        if(pass == 0) {
3691
 
            // packets can sometimes contain multiple PPS/SPS
3692
 
            // e.g. two PAFF field pictures in one packet, or a demuxer which splits NALs strangely
3693
 
            // if so, when frame threading we can't start the next thread until we've read all of them
3694
 
            switch (hx->nal_unit_type) {
3695
 
                case NAL_SPS:
3696
 
                case NAL_PPS:
3697
 
                case NAL_IDR_SLICE:
3698
 
                case NAL_SLICE:
3699
 
                    nals_needed = nal_index;
3700
 
            }
3701
 
            continue;
3702
 
        }
3703
 
 
3704
 
        //FIXME do not discard SEI id
3705
 
        if(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0)
3706
 
            continue;
3707
 
 
3708
 
      again:
3709
 
        err = 0;
3710
 
        switch(hx->nal_unit_type){
3711
 
        case NAL_IDR_SLICE:
3712
 
            if (h->nal_unit_type != NAL_IDR_SLICE) {
3713
 
                av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices");
3714
 
                return -1;
3715
 
            }
3716
 
            idr(h); //FIXME ensure we don't loose some frames if there is reordering
3717
 
        case NAL_SLICE:
3718
 
            init_get_bits(&hx->s.gb, ptr, bit_length);
3719
 
            hx->intra_gb_ptr=
3720
 
            hx->inter_gb_ptr= &hx->s.gb;
3721
 
            hx->s.data_partitioning = 0;
3722
 
 
3723
 
            if((err = decode_slice_header(hx, h)))
3724
 
               break;
3725
 
 
3726
 
            s->current_picture_ptr->key_frame |=
3727
 
                    (hx->nal_unit_type == NAL_IDR_SLICE) ||
3728
 
                    (h->sei_recovery_frame_cnt >= 0);
3729
 
 
3730
 
            if (h->current_slice == 1) {
3731
 
                if(!(s->flags2 & CODEC_FLAG2_CHUNKS)) {
3732
 
                    decode_postinit(h, nal_index >= nals_needed);
3733
 
                }
3734
 
 
3735
 
                if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)
3736
 
                    return -1;
3737
 
                if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
3738
 
                    ff_vdpau_h264_picture_start(s);
3739
 
            }
3740
 
 
3741
 
            if(hx->redundant_pic_count==0
3742
 
               && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
3743
 
               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=AV_PICTURE_TYPE_B)
3744
 
               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==AV_PICTURE_TYPE_I)
3745
 
               && avctx->skip_frame < AVDISCARD_ALL){
3746
 
                if(avctx->hwaccel) {
3747
 
                    if (avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], consumed) < 0)
3748
 
                        return -1;
3749
 
                }else
3750
 
                if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
3751
 
                    static const uint8_t start_code[] = {0x00, 0x00, 0x01};
3752
 
                    ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code));
3753
 
                    ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed );
3754
 
                }else
3755
 
                    context_count++;
3756
 
            }
3757
 
            break;
3758
 
        case NAL_DPA:
3759
 
            init_get_bits(&hx->s.gb, ptr, bit_length);
3760
 
            hx->intra_gb_ptr=
3761
 
            hx->inter_gb_ptr= NULL;
3762
 
 
3763
 
            if ((err = decode_slice_header(hx, h)) < 0)
3764
 
                break;
3765
 
 
3766
 
            hx->s.data_partitioning = 1;
3767
 
 
3768
 
            break;
3769
 
        case NAL_DPB:
3770
 
            init_get_bits(&hx->intra_gb, ptr, bit_length);
3771
 
            hx->intra_gb_ptr= &hx->intra_gb;
3772
 
            break;
3773
 
        case NAL_DPC:
3774
 
            init_get_bits(&hx->inter_gb, ptr, bit_length);
3775
 
            hx->inter_gb_ptr= &hx->inter_gb;
3776
 
 
3777
 
            if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning
3778
 
               && s->context_initialized
3779
 
               && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
3780
 
               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=AV_PICTURE_TYPE_B)
3781
 
               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==AV_PICTURE_TYPE_I)
3782
 
               && avctx->skip_frame < AVDISCARD_ALL)
3783
 
                context_count++;
3784
 
            break;
3785
 
        case NAL_SEI:
3786
 
            init_get_bits(&s->gb, ptr, bit_length);
3787
 
            ff_h264_decode_sei(h);
3788
 
            break;
3789
 
        case NAL_SPS:
3790
 
            init_get_bits(&s->gb, ptr, bit_length);
3791
 
            ff_h264_decode_seq_parameter_set(h);
3792
 
 
3793
 
            if (s->flags& CODEC_FLAG_LOW_DELAY ||
3794
 
                (h->sps.bitstream_restriction_flag && !h->sps.num_reorder_frames))
3795
 
                s->low_delay=1;
3796
 
 
3797
 
            if(avctx->has_b_frames < 2)
3798
 
                avctx->has_b_frames= !s->low_delay;
3799
 
 
3800
 
            if (avctx->bits_per_raw_sample != h->sps.bit_depth_luma) {
3801
 
                if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
3802
 
                    avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
3803
 
                    h->pixel_shift = h->sps.bit_depth_luma > 8;
3804
 
 
3805
 
                    ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma);
3806
 
                    ff_h264_pred_init(&h->hpc, s->codec_id, h->sps.bit_depth_luma);
3807
 
                    dsputil_init(&s->dsp, s->avctx);
3808
 
                } else {
3809
 
                    av_log(avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d\n", h->sps.bit_depth_luma);
3810
 
                    return -1;
3811
 
                }
3812
 
            }
3813
 
            break;
3814
 
        case NAL_PPS:
3815
 
            init_get_bits(&s->gb, ptr, bit_length);
3816
 
 
3817
 
            ff_h264_decode_picture_parameter_set(h, bit_length);
3818
 
 
3819
 
            break;
3820
 
        case NAL_AUD:
3821
 
        case NAL_END_SEQUENCE:
3822
 
        case NAL_END_STREAM:
3823
 
        case NAL_FILLER_DATA:
3824
 
        case NAL_SPS_EXT:
3825
 
        case NAL_AUXILIARY_SLICE:
3826
 
            break;
3827
 
        default:
3828
 
            av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", hx->nal_unit_type, bit_length);
3829
 
        }
3830
 
 
3831
 
        if(context_count == h->max_contexts) {
3832
 
            execute_decode_slices(h, context_count);
3833
 
            context_count = 0;
3834
 
        }
3835
 
 
3836
 
        if (err < 0)
3837
 
            av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
3838
 
        else if(err == 1) {
3839
 
            /* Slice could not be decoded in parallel mode, copy down
3840
 
             * NAL unit stuff to context 0 and restart. Note that
3841
 
             * rbsp_buffer is not transferred, but since we no longer
3842
 
             * run in parallel mode this should not be an issue. */
3843
 
            h->nal_unit_type = hx->nal_unit_type;
3844
 
            h->nal_ref_idc   = hx->nal_ref_idc;
3845
 
            hx = h;
3846
 
            goto again;
3847
 
        }
3848
 
    }
3849
 
    }
3850
 
    if(context_count)
3851
 
        execute_decode_slices(h, context_count);
3852
 
    return buf_index;
3853
 
}
3854
 
 
3855
 
/**
3856
 
 * returns the number of bytes consumed for building the current frame
3857
 
 */
3858
 
static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
3859
 
        if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
3860
 
        if(pos+10>buf_size) pos=buf_size; // oops ;)
3861
 
 
3862
 
        return pos;
3863
 
}
3864
 
 
3865
 
static int decode_frame(AVCodecContext *avctx,
3866
 
                             void *data, int *data_size,
3867
 
                             AVPacket *avpkt)
3868
 
{
3869
 
    const uint8_t *buf = avpkt->data;
3870
 
    int buf_size = avpkt->size;
3871
 
    H264Context *h = avctx->priv_data;
3872
 
    MpegEncContext *s = &h->s;
3873
 
    AVFrame *pict = data;
3874
 
    int buf_index;
3875
 
 
3876
 
    s->flags= avctx->flags;
3877
 
    s->flags2= avctx->flags2;
3878
 
 
3879
 
   /* end of stream, output what is still in the buffers */
3880
 
 out:
3881
 
    if (buf_size == 0) {
3882
 
        Picture *out;
3883
 
        int i, out_idx;
3884
 
 
3885
 
        s->current_picture_ptr = NULL;
3886
 
 
3887
 
//FIXME factorize this with the output code below
3888
 
        out = h->delayed_pic[0];
3889
 
        out_idx = 0;
3890
 
        for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
3891
 
            if(h->delayed_pic[i]->poc < out->poc){
3892
 
                out = h->delayed_pic[i];
3893
 
                out_idx = i;
3894
 
            }
3895
 
 
3896
 
        for(i=out_idx; h->delayed_pic[i]; i++)
3897
 
            h->delayed_pic[i] = h->delayed_pic[i+1];
3898
 
 
3899
 
        if(out){
3900
 
            *data_size = sizeof(AVFrame);
3901
 
            *pict= *(AVFrame*)out;
3902
 
        }
3903
 
 
3904
 
        return 0;
3905
 
    }
3906
 
 
3907
 
    buf_index=decode_nal_units(h, buf, buf_size);
3908
 
    if(buf_index < 0)
3909
 
        return -1;
3910
 
 
3911
 
    if (!s->current_picture_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {
3912
 
        buf_size = 0;
3913
 
        goto out;
3914
 
    }
3915
 
 
3916
 
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){
3917
 
        if (avctx->skip_frame >= AVDISCARD_NONREF)
3918
 
            return 0;
3919
 
        av_log(avctx, AV_LOG_ERROR, "no frame!\n");
3920
 
        return -1;
3921
 
    }
3922
 
 
3923
 
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){
3924
 
 
3925
 
        if(s->flags2 & CODEC_FLAG2_CHUNKS) decode_postinit(h, 1);
3926
 
 
3927
 
        field_end(h, 0);
3928
 
 
3929
 
        if (!h->next_output_pic) {
3930
 
            /* Wait for second field. */
3931
 
            *data_size = 0;
3932
 
 
3933
 
        } else {
3934
 
            *data_size = sizeof(AVFrame);
3935
 
            *pict = *(AVFrame*)h->next_output_pic;
3936
 
        }
3937
 
    }
3938
 
 
3939
 
    assert(pict->data[0] || !*data_size);
3940
 
    ff_print_debug_info(s, pict);
3941
 
//printf("out %d\n", (int)pict->data[0]);
3942
 
 
3943
 
    return get_consumed_bytes(s, buf_index, buf_size);
3944
 
}
3945
 
#if 0
3946
 
static inline void fill_mb_avail(H264Context *h){
3947
 
    MpegEncContext * const s = &h->s;
3948
 
    const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
3949
 
 
3950
 
    if(s->mb_y){
3951
 
        h->mb_avail[0]= s->mb_x                 && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
3952
 
        h->mb_avail[1]=                            h->slice_table[mb_xy - s->mb_stride    ] == h->slice_num;
3953
 
        h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
3954
 
    }else{
3955
 
        h->mb_avail[0]=
3956
 
        h->mb_avail[1]=
3957
 
        h->mb_avail[2]= 0;
3958
 
    }
3959
 
    h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
3960
 
    h->mb_avail[4]= 1; //FIXME move out
3961
 
    h->mb_avail[5]= 0; //FIXME move out
3962
 
}
3963
 
#endif
3964
 
 
3965
 
#ifdef TEST
3966
 
#undef printf
3967
 
#undef random
3968
 
#define COUNT 8000
3969
 
#define SIZE (COUNT*40)
3970
 
int main(void){
3971
 
    int i;
3972
 
    uint8_t temp[SIZE];
3973
 
    PutBitContext pb;
3974
 
    GetBitContext gb;
3975
 
//    int int_temp[10000];
3976
 
    DSPContext dsp;
3977
 
    AVCodecContext avctx;
3978
 
 
3979
 
    dsputil_init(&dsp, &avctx);
3980
 
 
3981
 
    init_put_bits(&pb, temp, SIZE);
3982
 
    printf("testing unsigned exp golomb\n");
3983
 
    for(i=0; i<COUNT; i++){
3984
 
        START_TIMER
3985
 
        set_ue_golomb(&pb, i);
3986
 
        STOP_TIMER("set_ue_golomb");
3987
 
    }
3988
 
    flush_put_bits(&pb);
3989
 
 
3990
 
    init_get_bits(&gb, temp, 8*SIZE);
3991
 
    for(i=0; i<COUNT; i++){
3992
 
        int j, s;
3993
 
 
3994
 
        s= show_bits(&gb, 24);
3995
 
 
3996
 
        START_TIMER
3997
 
        j= get_ue_golomb(&gb);
3998
 
        if(j != i){
3999
 
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
4000
 
//            return -1;
4001
 
        }
4002
 
        STOP_TIMER("get_ue_golomb");
4003
 
    }
4004
 
 
4005
 
 
4006
 
    init_put_bits(&pb, temp, SIZE);
4007
 
    printf("testing signed exp golomb\n");
4008
 
    for(i=0; i<COUNT; i++){
4009
 
        START_TIMER
4010
 
        set_se_golomb(&pb, i - COUNT/2);
4011
 
        STOP_TIMER("set_se_golomb");
4012
 
    }
4013
 
    flush_put_bits(&pb);
4014
 
 
4015
 
    init_get_bits(&gb, temp, 8*SIZE);
4016
 
    for(i=0; i<COUNT; i++){
4017
 
        int j, s;
4018
 
 
4019
 
        s= show_bits(&gb, 24);
4020
 
 
4021
 
        START_TIMER
4022
 
        j= get_se_golomb(&gb);
4023
 
        if(j != i - COUNT/2){
4024
 
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
4025
 
//            return -1;
4026
 
        }
4027
 
        STOP_TIMER("get_se_golomb");
4028
 
    }
4029
 
 
4030
 
#if 0
4031
 
    printf("testing 4x4 (I)DCT\n");
4032
 
 
4033
 
    DCTELEM block[16];
4034
 
    uint8_t src[16], ref[16];
4035
 
    uint64_t error= 0, max_error=0;
4036
 
 
4037
 
    for(i=0; i<COUNT; i++){
4038
 
        int j;
4039
 
//        printf("%d %d %d\n", r1, r2, (r2-r1)*16);
4040
 
        for(j=0; j<16; j++){
4041
 
            ref[j]= random()%255;
4042
 
            src[j]= random()%255;
4043
 
        }
4044
 
 
4045
 
        h264_diff_dct_c(block, src, ref, 4);
4046
 
 
4047
 
        //normalize
4048
 
        for(j=0; j<16; j++){
4049
 
//            printf("%d ", block[j]);
4050
 
            block[j]= block[j]*4;
4051
 
            if(j&1) block[j]= (block[j]*4 + 2)/5;
4052
 
            if(j&4) block[j]= (block[j]*4 + 2)/5;
4053
 
        }
4054
 
//        printf("\n");
4055
 
 
4056
 
        h->h264dsp.h264_idct_add(ref, block, 4);
4057
 
/*        for(j=0; j<16; j++){
4058
 
            printf("%d ", ref[j]);
4059
 
        }
4060
 
        printf("\n");*/
4061
 
 
4062
 
        for(j=0; j<16; j++){
4063
 
            int diff= FFABS(src[j] - ref[j]);
4064
 
 
4065
 
            error+= diff*diff;
4066
 
            max_error= FFMAX(max_error, diff);
4067
 
        }
4068
 
    }
4069
 
    printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
4070
 
    printf("testing quantizer\n");
4071
 
    for(qp=0; qp<52; qp++){
4072
 
        for(i=0; i<16; i++)
4073
 
            src1_block[i]= src2_block[i]= random()%255;
4074
 
 
4075
 
    }
4076
 
    printf("Testing NAL layer\n");
4077
 
 
4078
 
    uint8_t bitstream[COUNT];
4079
 
    uint8_t nal[COUNT*2];
4080
 
    H264Context h;
4081
 
    memset(&h, 0, sizeof(H264Context));
4082
 
 
4083
 
    for(i=0; i<COUNT; i++){
4084
 
        int zeros= i;
4085
 
        int nal_length;
4086
 
        int consumed;
4087
 
        int out_length;
4088
 
        uint8_t *out;
4089
 
        int j;
4090
 
 
4091
 
        for(j=0; j<COUNT; j++){
4092
 
            bitstream[j]= (random() % 255) + 1;
4093
 
        }
4094
 
 
4095
 
        for(j=0; j<zeros; j++){
4096
 
            int pos= random() % COUNT;
4097
 
            while(bitstream[pos] == 0){
4098
 
                pos++;
4099
 
                pos %= COUNT;
4100
 
            }
4101
 
            bitstream[pos]=0;
4102
 
        }
4103
 
 
4104
 
        START_TIMER
4105
 
 
4106
 
        nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
4107
 
        if(nal_length<0){
4108
 
            printf("encoding failed\n");
4109
 
            return -1;
4110
 
        }
4111
 
 
4112
 
        out= ff_h264_decode_nal(&h, nal, &out_length, &consumed, nal_length);
4113
 
 
4114
 
        STOP_TIMER("NAL")
4115
 
 
4116
 
        if(out_length != COUNT){
4117
 
            printf("incorrect length %d %d\n", out_length, COUNT);
4118
 
            return -1;
4119
 
        }
4120
 
 
4121
 
        if(consumed != nal_length){
4122
 
            printf("incorrect consumed length %d %d\n", nal_length, consumed);
4123
 
            return -1;
4124
 
        }
4125
 
 
4126
 
        if(memcmp(bitstream, out, COUNT)){
4127
 
            printf("mismatch\n");
4128
 
            return -1;
4129
 
        }
4130
 
    }
4131
 
#endif
4132
 
 
4133
 
    printf("Testing RBSP\n");
4134
 
 
4135
 
 
4136
 
    return 0;
4137
 
}
4138
 
#endif /* TEST */
4139
 
 
4140
 
 
4141
 
av_cold void ff_h264_free_context(H264Context *h)
4142
 
{
4143
 
    int i;
4144
 
 
4145
 
    free_tables(h, 1); //FIXME cleanup init stuff perhaps
4146
 
 
4147
 
    for(i = 0; i < MAX_SPS_COUNT; i++)
4148
 
        av_freep(h->sps_buffers + i);
4149
 
 
4150
 
    for(i = 0; i < MAX_PPS_COUNT; i++)
4151
 
        av_freep(h->pps_buffers + i);
4152
 
}
4153
 
 
4154
 
av_cold int ff_h264_decode_end(AVCodecContext *avctx)
4155
 
{
4156
 
    H264Context *h = avctx->priv_data;
4157
 
    MpegEncContext *s = &h->s;
4158
 
 
4159
 
    ff_h264_free_context(h);
4160
 
 
4161
 
    MPV_common_end(s);
4162
 
 
4163
 
//    memset(h, 0, sizeof(H264Context));
4164
 
 
4165
 
    return 0;
4166
 
}
4167
 
 
4168
 
static const AVProfile profiles[] = {
4169
 
    { FF_PROFILE_H264_BASELINE,             "Baseline"              },
4170
 
    { FF_PROFILE_H264_CONSTRAINED_BASELINE, "Constrained Baseline"  },
4171
 
    { FF_PROFILE_H264_MAIN,                 "Main"                  },
4172
 
    { FF_PROFILE_H264_EXTENDED,             "Extended"              },
4173
 
    { FF_PROFILE_H264_HIGH,                 "High"                  },
4174
 
    { FF_PROFILE_H264_HIGH_10,              "High 10"               },
4175
 
    { FF_PROFILE_H264_HIGH_10_INTRA,        "High 10 Intra"         },
4176
 
    { FF_PROFILE_H264_HIGH_422,             "High 4:2:2"            },
4177
 
    { FF_PROFILE_H264_HIGH_422_INTRA,       "High 4:2:2 Intra"      },
4178
 
    { FF_PROFILE_H264_HIGH_444,             "High 4:4:4"            },
4179
 
    { FF_PROFILE_H264_HIGH_444_PREDICTIVE,  "High 4:4:4 Predictive" },
4180
 
    { FF_PROFILE_H264_HIGH_444_INTRA,       "High 4:4:4 Intra"      },
4181
 
    { FF_PROFILE_H264_CAVLC_444,            "CAVLC 4:4:4"           },
4182
 
    { FF_PROFILE_UNKNOWN },
4183
 
};
4184
 
 
4185
 
AVCodec ff_h264_decoder = {
4186
 
    "h264",
4187
 
    AVMEDIA_TYPE_VIDEO,
4188
 
    CODEC_ID_H264,
4189
 
    sizeof(H264Context),
4190
 
    ff_h264_decode_init,
4191
 
    NULL,
4192
 
    ff_h264_decode_end,
4193
 
    decode_frame,
4194
 
    /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
4195
 
        CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
4196
 
    .flush= flush_dpb,
4197
 
    .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
4198
 
    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
4199
 
    .update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),
4200
 
    .profiles = NULL_IF_CONFIG_SMALL(profiles),
4201
 
};
4202
 
 
4203
 
#if CONFIG_H264_VDPAU_DECODER
4204
 
AVCodec ff_h264_vdpau_decoder = {
4205
 
    "h264_vdpau",
4206
 
    AVMEDIA_TYPE_VIDEO,
4207
 
    CODEC_ID_H264,
4208
 
    sizeof(H264Context),
4209
 
    ff_h264_decode_init,
4210
 
    NULL,
4211
 
    ff_h264_decode_end,
4212
 
    decode_frame,
4213
 
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
4214
 
    .flush= flush_dpb,
4215
 
    .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
4216
 
    .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE},
4217
 
    .profiles = NULL_IF_CONFIG_SMALL(profiles),
4218
 
};
4219
 
#endif