PeerStreamer

    int perms = AV_PERM_WRITE;

    int i, w, h, stride[4];

    unsigned edge;

    av_assert0(codec->flags & CODEC_FLAG_EMU_EDGE);

    if(!(ref = avfilter_get_video_buffer(ctx->outputs[0], perms, w, h)))

        return -1;

    ref->video->w = codec->width;

    ref->video->h = codec->height;

    for(i = 0; i < 4; i ++) {

        unsigned vshift = (i == 1 || i == 2) ? av_pix_fmt_descriptors[ref->format].log2_chroma_h : 0;

        if (ref->data[i]) {

        }

        pic->data[i]     = ref->data[i];

        pic->linesize[i] = ref->linesize[i];

    const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;

    int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;

    const int luma_xy= (mx&3) + ((my&3)<<2);

    uint8_t * src_cb, * src_cr;

    int extra_width= h->emu_edge_width;

    int extra_height= h->emu_edge_height;

       || full_my < 0-extra_height

       || full_mx + 16/*FIXME*/ > pic_width + extra_width

       || full_my + 16/*FIXME*/ > pic_height + extra_height){

        emu=1;

    }

        my += 2 * ((s->mb_y & 1) - (pic->reference - 1));

        emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);

    }

    if(emu){

        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);

    qpel_mc_func *qpix_op=  qpix_put;

    h264_chroma_mc_func chroma_op= chroma_put;

    x_offset += 8*s->mb_x;

    y_offset += 8*(s->mb_y >> MB_FIELD);

                           int list0, int list1){

    MpegEncContext * const s = &h->s;

    x_offset += 8*s->mb_x;

    y_offset += 8*(s->mb_y >> MB_FIELD);

        /* don't optimize for luma-only case, since B-frames usually

         * use implicit weights => chroma too. */

        uint8_t *tmp_cb = s->obmc_scratchpad;

        uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;

        int refn0 = h->ref_cache[0][ scan8[n] ];

        int refn1 = h->ref_cache[1][ scan8[n] ];

        const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;

        const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;

        uint8_t **src= h->ref_list[list][refn].data;

        s->dsp.prefetch(src[0]+off, s->linesize, 4);

        s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);

    }

}

                weight_op, weight_avg,

                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

    }else if(IS_16X8(mb_type)){

                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

                &weight_op[1], &weight_avg[1],

                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

                &weight_op[1], &weight_avg[1],

                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));

                    &weight_op[3], &weight_avg[3],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

            }else if(IS_SUB_8X4(sub_mb_type)){

                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

                    &weight_op[4], &weight_avg[4],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

                    &weight_op[4], &weight_avg[4],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

 * Allocate buffers which are not shared amongst multiple threads.

 */

static int context_init(H264Context *h){

    h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =

    h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;

    ff_h264_decode_init_vlc();

    h->thread_context[0] = h;

    h->outputed_poc = h->next_outputed_poc = INT_MIN;

    h->prev_poc_msb= 1<<16;

    assert(s->linesize && s->uvlinesize);

    for(i=0; i<16; i++){

    }

    for(i=0; i<4; i++){

        h->block_offset[16+i]=

        h->block_offset[24+16+i]=

    }

    /* can't be in alloc_tables because linesize isn't known there.

            if(!MB_MBAFF){

                top_border = h->top_borders[0][s->mb_x];

                AV_COPY128(top_border, src_y + 15*linesize);

                if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

                    AV_COPY64(top_border+16, src_cb+7*uvlinesize);

                    AV_COPY64(top_border+24, src_cr+7*uvlinesize);

                }

            }

        }else if(MB_MBAFF){

    // There are two lines saved, the line above the the top macroblock of a pair,

    // and the line above the bottom macroblock

    AV_COPY128(top_border, src_y + 16*linesize);

    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

        AV_COPY64(top_border+16, src_cb+8*uvlinesize);

        AV_COPY64(top_border+24, src_cr+8*uvlinesize);

    }

}

        deblock_top =  (s->mb_y > !!MB_FIELD);

    }

    top_border_m1 = h->top_borders[top_idx][s->mb_x-1];

    top_border    = h->top_borders[top_idx][s->mb_x];

#define XCHG(a,b,xchg)\

if (xchg) AV_SWAP64(b,a);\

else      AV_COPY64(b,a);

    if(deblock_top){

        if(deblock_left){

        }

        if(s->mb_x+1 < s->mb_width){

        }

    }

    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

        if(deblock_top){

            if(deblock_left){

            }

        }

    }

}

static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){

    MpegEncContext * const s = &h->s;

    const int mb_x= s->mb_x;

    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);

    void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);

    h->list_counts[mb_xy]= h->list_count;

    }

    if (!simple && IS_INTRA_PCM(mb_type)) {

        for (i=0; i<16; i++) {

            memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);

        }

            memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);

            memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);

        }

    } else {

        if(IS_INTRA(mb_type)){

            if(h->deblocking_filter)

                            uint8_t * const ptr= dest_y + block_offset[i];

                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){

                            }else{

                                const int nnz = h->non_zero_count_cache[ scan8[i] ];

                                h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,

                                                            (h->topright_samples_available<<i)&0x4000, linesize);

                                if(nnz){

                                    else

                                }

                            }

                        }

                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){

                            }else{

                                uint8_t *topright;

                                int nnz, tr;

                                if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){

                                    const int topright_avail= (h->topright_samples_available<<i)&0x8000;

                                    assert(mb_y || linesize <= block_offset[i]);

                                    if(!topright_avail){

                                        tr= ptr[3 - linesize]*0x01010101;

                                        topright= (uint8_t*) &tr;

                                    }else

                                }else

                                    topright= NULL;

                                nnz = h->non_zero_count_cache[ scan8[i] ];

                                if(nnz){

                                    if(is_h264){

                                        else

                                    }

#if CONFIG_SVQ3_DECODER

                                    else

                            static const uint8_t dc_mapping[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,

                                                                    8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};

                            for(i = 0; i < 16; i++)

                        }

                    }

                }

                            h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);

                        }else{

                            for(i=0; i<16; i++){

                            }

                        }

                    }else{

                        idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;

                        for(i=0; i<16; i+=di){

                            if(h->non_zero_count_cache[ scan8[i] ]){

                            }

                        }

                    }else{

            uint8_t *dest[2] = {dest_cb, dest_cr};

            if(transform_bypass){

                if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){

                }else{

                    idct_add = s->dsp.add_pixels4;

                    for(i=16; i<16+8; i++){

                    }

                }

            }else{

                if(is_h264){

                    if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+0] ])

                    if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+1] ])

                    h->h264dsp.h264_idct_add8(dest, block_offset,

                                              h->mb, uvlinesize,

                                              h->non_zero_count_cache);

                s->mb_x= mb_x;

                s->mb_y= mb_y;

                    //FIXME simplify above

                if (MB_FIELD) {

typedef struct H264Context{

    MpegEncContext s;

    H264DSPContext h264dsp;

    int chroma_qp[2]; //QPc

    int qp_thresh;      ///< QP threshold to skip loopfilter

    unsigned int top_samples_available;

    unsigned int topright_samples_available;

    unsigned int left_samples_available;

    /**

     * non zero coeff count cache.

    GetBitContext *intra_gb_ptr;

    GetBitContext *inter_gb_ptr;

    /**

     * Cabac

        int j= scantable[index[--coeff_count]];

        }

    } while( coeff_count );

#ifdef CABAC_ON_STACK

    h->slice_table[ mb_xy ]= h->slice_num;

    if(IS_INTRA_PCM(mb_type)) {

        const uint8_t *ptr;

        // We assume these blocks are very rare so we do not optimize it.

        }

        // The pixels are stored in the same order as levels in h->mb array.

        if(CHROMA){

        }

        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);

            //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );

            AV_ZERO128(h->mb_luma_dc+0);

            AV_ZERO128(h->mb_luma_dc+8);

            decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);

            if( cbp&15 ) {

                qmul = h->dequant4_coeff[0][s->qscale];

                for( i = 0; i < 16; i++ ) {

                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );

                }

            } else {

                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);

            for( i8x8 = 0; i8x8 < 4; i8x8++ ) {

                if( cbp & (1<<i8x8) ) {

                    if( IS_8x8DCT(mb_type) ) {

                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);

                    } else {

                        qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];

                            const int index = 4*i8x8 + i4x4;

                            //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );

//START_TIMER

//STOP_TIMER("decode_residual")

                        }

                    }

            int c;

            for( c = 0; c < 2; c++ ) {

                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );

            }

        }

                for( i = 0; i < 4; i++ ) {

                    const int index = 16 + 4 * c + i;

                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );

                }

            }

        } else {

            zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);

    }

    }

    if(zeros_left<0){

        align_get_bits(&s->gb);

        // The pixels are stored in the same order as levels in h->mb array.

            ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);

        }

        if(IS_INTRA16x16(mb_type)){

            AV_ZERO128(h->mb_luma_dc+0);

            AV_ZERO128(h->mb_luma_dc+8);

            if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc, LUMA_DC_BLOCK_INDEX, scan, h->dequant4_coeff[0][s->qscale], 16) < 0){

                return -1; //FIXME continue if partitioned and other return -1 too

            }

                for(i8x8=0; i8x8<4; i8x8++){

                    for(i4x4=0; i4x4<4; i4x4++){

                        const int index= i4x4 + 4*i8x8;

                            return -1;

                        }

                    }

            for(i8x8=0; i8x8<4; i8x8++){

                if(cbp & (1<<i8x8)){

                    if(IS_8x8DCT(mb_type)){

                        uint8_t *nnz;

                        for(i4x4=0; i4x4<4; i4x4++){

                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,

                        for(i4x4=0; i4x4<4; i4x4++){

                            const int index= i4x4 + 4*i8x8;

                                return -1;

                            }

                        }

        if(cbp&0x30){

            for(chroma_idx=0; chroma_idx<2; chroma_idx++)

                    return -1;

                }

        }

                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];

                for(i4x4=0; i4x4<4; i4x4++){

                    const int index= 16 + 4*chroma_idx + i4x4;

                        return -1;

                    }

                }

        tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);

        //{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }

        if( dir == 0 ) {

            if( (edge&1) == 0 ) {

            }

        } else {

            filter_mb_edgeh( &img_y[4*edge*linesize], linesize, bS, qp, h );

        int unaligned;

        AVPicture picture;

        int stride_align[4];

        avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);

            if((s->flags&CODEC_FLAG_EMU_EDGE) || !size[2])

                buf->data[i] = buf->base[i];

            else

        }

        if(size[1] && !size[2])

            ff_set_systematic_pal2((uint32_t*)buf->data[1], s->pix_fmt);