PeerStreamer

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