PeerStreamer

#include "thread.h"

static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height,

                                 int y_offset, int list){

    int raw_my= h->mv_cache[list][ scan8[n] ][1];

    int filter_height= (raw_my&3) ? 2 : 0;

    int full_my= (raw_my>>2) + y_offset;

    int top = full_my - filter_height, bottom = full_my + height + filter_height;

    return FFMAX(abs(top), bottom);

}

static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,

                               int y_offset, int list0, int list1, int *nrefs){

    MpegEncContext * const s = &h->s;

    int my;

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

    if(list0){

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

        Picture *ref= &h->ref_list[0][ref_n];

        // Error resilience puts the current picture in the ref list.

        // Don't try to wait on these as it will cause a deadlock.

        // Fields can wait on each other, though.

        if(ref->thread_opaque != s->current_picture.thread_opaque ||

           (ref->reference&3) != s->picture_structure) {

            my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);

            if (refs[0][ref_n] < 0) nrefs[0] += 1;

            refs[0][ref_n] = FFMAX(refs[0][ref_n], my);

        }

    }

    if(list1){

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

        Picture *ref= &h->ref_list[1][ref_n];

        if(ref->thread_opaque != s->current_picture.thread_opaque ||

           (ref->reference&3) != s->picture_structure) {

            my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);

            if (refs[1][ref_n] < 0) nrefs[1] += 1;

            refs[1][ref_n] = FFMAX(refs[1][ref_n], my);

        }

    }

}

/**

 * Wait until all reference frames are available for MC operations.

 *

 * @param h the H264 context

 */

static void await_references(H264Context *h){

    MpegEncContext * const s = &h->s;

    const int mb_xy= h->mb_xy;

    const int mb_type= s->current_picture.mb_type[mb_xy];

    int refs[2][48];

    int nrefs[2] = {0};

    int ref, list;

    memset(refs, -1, sizeof(refs));

    if(IS_16X16(mb_type)){

        get_lowest_part_y(h, refs, 0, 16, 0,

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

    }else if(IS_16X8(mb_type)){

        get_lowest_part_y(h, refs, 0, 8, 0,

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

        get_lowest_part_y(h, refs, 8, 8, 8,

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

    }else if(IS_8X16(mb_type)){

        get_lowest_part_y(h, refs, 0, 16, 0,

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

        get_lowest_part_y(h, refs, 4, 16, 0,

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

    }else{

        int i;

        assert(IS_8X8(mb_type));

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

            const int sub_mb_type= h->sub_mb_type[i];

            const int n= 4*i;

            int y_offset= (i&2)<<2;

            if(IS_SUB_8X8(sub_mb_type)){

                get_lowest_part_y(h, refs, n  , 8, y_offset,

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

            }else if(IS_SUB_8X4(sub_mb_type)){

                get_lowest_part_y(h, refs, n  , 4, y_offset,

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

                get_lowest_part_y(h, refs, n+2, 4, y_offset+4,

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

            }else if(IS_SUB_4X8(sub_mb_type)){

                get_lowest_part_y(h, refs, n  , 8, y_offset,

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

                get_lowest_part_y(h, refs, n+1, 8, y_offset,

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

            }else{

                int j;

                assert(IS_SUB_4X4(sub_mb_type));

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

                    int sub_y_offset= y_offset + 2*(j&2);

                    get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,

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

                }

            }

        }

    }

    for(list=h->list_count-1; list>=0; list--){

        for(ref=0; ref<48 && nrefs[list]; ref++){

            int row = refs[list][ref];

            if(row >= 0){

                Picture *ref_pic = &h->ref_list[list][ref];

                int ref_field = ref_pic->reference - 1;

                int ref_field_picture = ref_pic->field_picture;

                int pic_height = 16*s->mb_height >> ref_field_picture;

                row <<= MB_MBAFF;

                nrefs[list]--;

                if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields

                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);

                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);

                }else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame

                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);

                }else if(FIELD_PICTURE){

                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);

                }else{

                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);

                }

            }

        }

    }

}

    if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME)

        await_references(h);

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

static void copy_picture_range(Picture **to, Picture **from, int count, MpegEncContext *new_base, MpegEncContext *old_base)

{

    int i;

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

        to[i] = REBASE_PICTURE(from[i], new_base, old_base);

    }

}

static void copy_parameter_set(void **to, void **from, int count, int size)

{

    int i;

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

        if (to[i] && !from[i]) av_freep(&to[i]);

        else if (from[i] && !to[i]) to[i] = av_malloc(size);

        if (from[i]) memcpy(to[i], from[i], size);

    }

}

static int decode_init_thread_copy(AVCodecContext *avctx){

    H264Context *h= avctx->priv_data;

    if (!avctx->is_copy) return 0;

    memset(h->sps_buffers, 0, sizeof(h->sps_buffers));

    memset(h->pps_buffers, 0, sizeof(h->pps_buffers));

    return 0;

}

#define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)

static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src){

    H264Context *h= dst->priv_data, *h1= src->priv_data;

    MpegEncContext * const s = &h->s, * const s1 = &h1->s;

    int inited = s->context_initialized, err;

    int i;

    if(dst == src || !s1->context_initialized) return 0;

    err = ff_mpeg_update_thread_context(dst, src);

    if(err) return err;

    //FIXME handle width/height changing

    if(!inited){

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

            av_freep(h->sps_buffers + i);

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

            av_freep(h->pps_buffers + i);

        memcpy(&h->s + 1, &h1->s + 1, sizeof(H264Context) - sizeof(MpegEncContext)); //copy all fields after MpegEnc

        memset(h->sps_buffers, 0, sizeof(h->sps_buffers));

        memset(h->pps_buffers, 0, sizeof(h->pps_buffers));

        ff_h264_alloc_tables(h);

        context_init(h);

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

            h->rbsp_buffer[i] = NULL;

            h->rbsp_buffer_size[i] = 0;

        }

        h->thread_context[0] = h;

        // frame_start may not be called for the next thread (if it's decoding a bottom field)

        // so this has to be allocated here

        h->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);

        s->dsp.clear_blocks(h->mb);

    }

    //extradata/NAL handling

    h->is_avc          = h1->is_avc;

    //SPS/PPS

    copy_parameter_set((void**)h->sps_buffers, (void**)h1->sps_buffers, MAX_SPS_COUNT, sizeof(SPS));

    h->sps             = h1->sps;

    copy_parameter_set((void**)h->pps_buffers, (void**)h1->pps_buffers, MAX_PPS_COUNT, sizeof(PPS));

    h->pps             = h1->pps;

    //Dequantization matrices

    //FIXME these are big - can they be only copied when PPS changes?

    copy_fields(h, h1, dequant4_buffer, dequant4_coeff);

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

        h->dequant4_coeff[i] = h->dequant4_buffer[0] + (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);

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

        h->dequant8_coeff[i] = h->dequant8_buffer[0] + (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);

    h->dequant_coeff_pps = h1->dequant_coeff_pps;

    //POC timing

    copy_fields(h, h1, poc_lsb, redundant_pic_count);

    //reference lists

    copy_fields(h, h1, ref_count, intra_gb);

    copy_fields(h, h1, short_ref, cabac_init_idc);

    copy_picture_range(h->short_ref,   h1->short_ref,   32, s, s1);

    copy_picture_range(h->long_ref,    h1->long_ref,    32,  s, s1);

    copy_picture_range(h->delayed_pic, h1->delayed_pic, MAX_DELAYED_PIC_COUNT+2, s, s1);

    h->last_slice_type = h1->last_slice_type;

    if(!s->current_picture_ptr) return 0;

    if(!s->dropable) {

        ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

        h->prev_poc_msb     = h->poc_msb;

        h->prev_poc_lsb     = h->poc_lsb;

    }

    h->prev_frame_num_offset= h->frame_num_offset;

    h->prev_frame_num       = h->frame_num;

    h->outputed_poc         = h->next_outputed_poc;

    return 0;

}

    h->next_output_pic = NULL;

/**

  * Run setup operations that must be run after slice header decoding.

  * This includes finding the next displayed frame.

  *

  * @param h h264 master context

  */

static void decode_postinit(H264Context *h){

    MpegEncContext * const s = &h->s;

    Picture *out = s->current_picture_ptr;

    Picture *cur = s->current_picture_ptr;

    int i, pics, out_of_order, out_idx;

    s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;

    s->current_picture_ptr->pict_type= s->pict_type;

    if (h->next_output_pic) return;

    if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {

        //FIXME this allows the next thread to start once we encounter the first field of a PAFF packet

        //This works if the next packet contains the second field. It does not work if both fields are

        //in the same packet.

        //ff_thread_finish_setup(s->avctx);

        return;

    }

    cur->interlaced_frame = 0;

    cur->repeat_pict = 0;

    /* Signal interlacing information externally. */

    /* Prioritize picture timing SEI information over used decoding process if it exists. */

    if(h->sps.pic_struct_present_flag){

        switch (h->sei_pic_struct)

        {

        case SEI_PIC_STRUCT_FRAME:

            break;

        case SEI_PIC_STRUCT_TOP_FIELD:

        case SEI_PIC_STRUCT_BOTTOM_FIELD:

            cur->interlaced_frame = 1;

            break;

        case SEI_PIC_STRUCT_TOP_BOTTOM:

        case SEI_PIC_STRUCT_BOTTOM_TOP:

            if (FIELD_OR_MBAFF_PICTURE)

                cur->interlaced_frame = 1;

            else

                // try to flag soft telecine progressive

                cur->interlaced_frame = h->prev_interlaced_frame;

            break;

        case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

        case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

            // Signal the possibility of telecined film externally (pic_struct 5,6)

            // From these hints, let the applications decide if they apply deinterlacing.

            cur->repeat_pict = 1;

            break;

        case SEI_PIC_STRUCT_FRAME_DOUBLING:

            // Force progressive here, as doubling interlaced frame is a bad idea.

            cur->repeat_pict = 2;

            break;

        case SEI_PIC_STRUCT_FRAME_TRIPLING:

            cur->repeat_pict = 4;

            break;

        }

        if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)

            cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;

    }else{

        /* Derive interlacing flag from used decoding process. */

        cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;

    }

    h->prev_interlaced_frame = cur->interlaced_frame;

    if (cur->field_poc[0] != cur->field_poc[1]){

        /* Derive top_field_first from field pocs. */

        cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];

    }else{

        if(cur->interlaced_frame || h->sps.pic_struct_present_flag){

            /* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */

            if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM

              || h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)

                cur->top_field_first = 1;

            else

                cur->top_field_first = 0;

        }else{

            /* Most likely progressive */

            cur->top_field_first = 0;

        }

    }

    //FIXME do something with unavailable reference frames

    /* Sort B-frames into display order */

    if(h->sps.bitstream_restriction_flag

       && s->avctx->has_b_frames < h->sps.num_reorder_frames){

        s->avctx->has_b_frames = h->sps.num_reorder_frames;

        s->low_delay = 0;

    }

    if(   s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT

       && !h->sps.bitstream_restriction_flag){

        s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;

        s->low_delay= 0;

    }

    pics = 0;

    while(h->delayed_pic[pics]) pics++;

    assert(pics <= MAX_DELAYED_PIC_COUNT);

    h->delayed_pic[pics++] = cur;

    if(cur->reference == 0)

        cur->reference = DELAYED_PIC_REF;

    out = h->delayed_pic[0];

    out_idx = 0;

    for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)

        if(h->delayed_pic[i]->poc < out->poc){

            out = h->delayed_pic[i];

            out_idx = i;

        }

    if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))

        h->next_outputed_poc= INT_MIN;

    out_of_order = out->poc < h->next_outputed_poc;

    if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)

        { }

    else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)

       || (s->low_delay &&

        ((h->next_outputed_poc != INT_MIN && out->poc > h->next_outputed_poc + 2)

         || cur->pict_type == FF_B_TYPE)))

    {

        s->low_delay = 0;

        s->avctx->has_b_frames++;

    }

    if(out_of_order || pics > s->avctx->has_b_frames){

        out->reference &= ~DELAYED_PIC_REF;

        for(i=out_idx; h->delayed_pic[i]; i++)

            h->delayed_pic[i] = h->delayed_pic[i+1];

    }

    if(!out_of_order && pics > s->avctx->has_b_frames){

        h->next_output_pic = out;

        if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {

            h->next_outputed_poc = INT_MIN;

        } else

            h->next_outputed_poc = out->poc;

    }else{

        av_log(s->avctx, AV_LOG_DEBUG, "no picture\n");

    }

    ff_thread_finish_setup(s->avctx);

}

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

static void field_end(H264Context *h, int in_setup){

    if (!in_setup && !s->dropable)

        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, (16*s->mb_height >> FIELD_PICTURE) - 1,

                                 s->picture_structure==PICT_BOTTOM_FIELD);

    if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){

        if(!s->dropable) {

            ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

            h->prev_poc_msb= h->poc_msb;

            h->prev_poc_lsb= h->poc_lsb;

        }

        h->prev_frame_num_offset= h->frame_num_offset;

        h->prev_frame_num= h->frame_num;

        h->outputed_poc = h->next_outputed_poc;

            field_end(h, 1);

        if(h != h0) {

            av_log_missing_feature(s->avctx, "Width/height changing with threads is", 0);

        }

        if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {

            if (context_init(h) < 0)

        } else {

            for(i = 1; i < s->avctx->thread_count; i++) {

                H264Context *c;

                c = h->thread_context[i] = av_malloc(sizeof(H264Context));

                memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));

                memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));

                c->h264dsp = h->h264dsp;

                c->sps = h->sps;

                c->pps = h->pps;

                init_scan_tables(c);

                clone_tables(c, h, i);

            }

            for(i = 0; i < s->avctx->thread_count; i++)

                if(context_init(h->thread_context[i]) < 0)

                    return -1;

        }

        if(h->frame_num != h->prev_frame_num &&

          (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num) < (h->frame_num - h->sps.ref_frame_count))

            h->prev_frame_num = h->frame_num - h->sps.ref_frame_count - 1;

            ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);

            ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);

    //FIXME mt gives valgrind warnings and crashes if this is uncommented

    /*

    */

    //FIXME: fix draw_edges+PAFF+frame threads

    h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE || (!h->sps.frame_mbs_only_flag && s->avctx->active_thread_type&FF_THREAD_FRAME)) ? 0 : 16;

/**

 * Draw edges and report progress for the last MB row.

 */

static void decode_finish_row(H264Context *h){

    MpegEncContext * const s = &h->s;

    int top = 16*(s->mb_y >> FIELD_PICTURE);

    int height = 16 << FRAME_MBAFF;

    int deblock_border = (16 + 4) << FRAME_MBAFF;

    int pic_height = 16*s->mb_height >> FIELD_PICTURE;

    if (h->deblocking_filter) {

        if((top + height) >= pic_height)

            height += deblock_border;

        top -= deblock_border;

    }

    if (top >= pic_height || (top + height) < h->emu_edge_height)

        return;

    height = FFMIN(height, pic_height - top);

    if (top < h->emu_edge_height) {

        height = top+height;

        top = 0;

    }

    ff_draw_horiz_band(s, top, height);

    if (s->dropable) return;

    ff_thread_report_progress((AVFrame*)s->current_picture_ptr, top + height - 1,

                             s->picture_structure==PICT_BOTTOM_FIELD);

}

                decode_finish_row(h);

                decode_finish_row(h);

    h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;

            s->current_picture_ptr->key_frame |=

                    (hx->nal_unit_type == NAL_IDR_SLICE) ||

                    (h->sei_recovery_frame_cnt >= 0);

                if(!(s->flags2 & CODEC_FLAG2_CHUNKS)) {

                    decode_postinit(h);

                }

        s->current_picture_ptr = NULL;

        if(s->flags2 & CODEC_FLAG2_CHUNKS) decode_postinit(h);

        field_end(h, 0);

        if (!h->next_output_pic) {

            *data_size = sizeof(AVFrame);

            *pict = *(AVFrame*)h->next_output_pic;

    /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_FRAME_THREADS,

    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

    .update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),