PeerStreamer

        s->mjpeg_hsample[0] = 2;

        s->mjpeg_hsample[1] = 2>>chroma_h_shift;

        s->mjpeg_hsample[2] = 2>>chroma_h_shift;

            || ff_mjpeg_encode_init(s) < 0)

            return -1;

        avctx->delay=0;

        s->low_delay=1;

        break;

    case CODEC_ID_H261:

        if (ff_h261_get_picture_format(s->width, s->height) < 0) {

            av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);

            return -1;

        s->low_delay=1;

        break;

    case CODEC_ID_H263:

        if (h263_get_picture_format(s->width, s->height) == 7) {

            av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);

            return -1;

    if(avctx->trellis)

        s->dct_quantize = dct_quantize_trellis_c;

        s->chroma_qscale_table= ff_h263_chroma_qscale_table;

    s->progressive_frame=

    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));

    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);

    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);

        ff_h261_encode_init(s);

        h263_encode_init(s);

        ff_msmpeg4_encode_init(s);

        && s->out_format == FMT_MPEG1)

        ff_mpeg1_encode_init(s);

    /* init q matrix */

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

        int j= s->dsp.idct_permutation[i];

            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];

            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];

        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){

    ff_rate_control_uninit(s);

    MPV_common_end(s);

        ff_mjpeg_encode_close(s);

    av_freep(&avctx->extradata);

        MPV_frame_end(s);

            ff_mjpeg_encode_picture_trailer(s);

        if(avctx->rc_buffer_size){

    switch(s->codec_id){ //FIXME funct ptr could be slightly faster

    case CODEC_ID_MPEG1VIDEO:

    case CODEC_ID_MPEG2VIDEO:

            mpeg1_encode_mb(s, s->block, motion_x, motion_y);

        break;

    case CODEC_ID_MPEG4:

            mpeg4_encode_mb(s, s->block, motion_x, motion_y);

        break;

    case CODEC_ID_MSMPEG4V2:

    case CODEC_ID_MSMPEG4V3:

    case CODEC_ID_WMV1:

            msmpeg4_encode_mb(s, s->block, motion_x, motion_y);

        break;

    case CODEC_ID_WMV2:

            ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);

        break;

    case CODEC_ID_H261:

            ff_h261_encode_mb(s, s->block, motion_x, motion_y);

        break;

    case CODEC_ID_H263:

    case CODEC_ID_FLV1:

    case CODEC_ID_RV10:

    case CODEC_ID_RV20:

            h263_encode_mb(s, s->block, motion_x, motion_y);

        break;

    case CODEC_ID_MJPEG:

            ff_mjpeg_encode_mb(s, s->block);

        break;

    default:

}

static void write_slice_end(MpegEncContext *s){

        if(s->partitioned_frame){

            ff_mpeg4_merge_partitions(s);

        }

        ff_mpeg4_stuffing(&s->pb);

        ff_mjpeg_encode_stuffing(&s->pb);

    }

    case CODEC_ID_H263:

    case CODEC_ID_H263P:

    case CODEC_ID_FLV1:

            s->gob_index = ff_h263_get_gob_height(s);

        break;

    case CODEC_ID_MPEG4:

            ff_mpeg4_init_partitions(s);

        break;

    }

            s->mb_y = mb_y;  // moved into loop, can get changed by H.261

            ff_update_block_index(s);

                ff_h261_reorder_mb_index(s);

                xy= s->mb_y*s->mb_stride + s->mb_x;

                mb_type= s->mb_type[xy];

                    if(s->start_mb_y != mb_y || mb_x!=0){

                        write_slice_end(s);

                            ff_mpeg4_init_partitions(s);

                        }

                    }

                    switch(s->codec_id){

                    case CODEC_ID_MPEG4:

                            ff_mpeg4_encode_video_packet_header(s);

                            ff_mpeg4_clean_buffers(s);

                        }

                    break;

                    case CODEC_ID_MPEG1VIDEO:

                    case CODEC_ID_MPEG2VIDEO:

                            ff_mpeg1_encode_slice_header(s);

                            ff_mpeg1_clean_buffers(s);

                        }

                    break;

                    case CODEC_ID_H263:

                    case CODEC_ID_H263P:

                            h263_encode_gob_header(s, mb_y);

                    break;

                    }

                        }

                    }

                }

                    int mx= s->b_direct_mv_table[xy][0];

                    int my= s->b_direct_mv_table[xy][1];

                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,

                                 &dmin, &next_block, mx, my);

                }

                    backup_s.dquant = 0;

                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;

                    s->mb_intra= 0;

                    if(coded){

                        int mx,my;

                        memcpy(s->mv, best_s.mv, sizeof(s->mv));

                            mx=my=0; //FIXME find the one we actually used

                            ff_mpeg4_set_direct_mv(s, mx, my);

                        }else if(best_s.mv_dir&MV_DIR_BACKWARD){

                }

                s->last_bits= put_bits_count(&s->pb);

                    s->out_format == FMT_H263 && s->pict_type!=FF_B_TYPE)

                    ff_h263_update_motion_val(s);

                    }

                    break;

                case CANDIDATE_MB_TYPE_DIRECT:

                        s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;

                        s->mb_intra= 0;

                        motion_x=s->b_direct_mv_table[xy][0];

                    }

                    break;

                case CANDIDATE_MB_TYPE_DIRECT0:

                        s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;

                        s->mb_intra= 0;

                        ff_mpeg4_set_direct_mv(s, 0, 0);

                // RAL: Update last macroblock type

                s->last_mv_dir = s->mv_dir;

                    s->out_format == FMT_H263 && s->pict_type!=FF_B_TYPE)

                    ff_h263_update_motion_val(s);

                    s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);

            }

            if(s->loop_filter){

                    ff_h263_loop_filter(s);

            }

//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));

    }

    //not beautiful here but we must write it before flushing so it has to be here

        msmpeg4_encode_ext_header(s);

    write_slice_end(s);

    if(s->adaptive_quant){

        switch(s->codec_id){

        case CODEC_ID_MPEG4:

                ff_clean_mpeg4_qscales(s);

            break;

        case CODEC_ID_H263:

        case CODEC_ID_H263P:

        case CODEC_ID_FLV1:

                ff_clean_h263_qscales(s);

            break;

        }

    // RAL: Condition added for MPEG1VIDEO

    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))

        set_frame_distances(s);

        ff_set_mpeg4_time(s);

    s->me.scene_change_score=0;

    s->last_bits= put_bits_count(&s->pb);

    switch(s->out_format) {

    case FMT_MJPEG:

            ff_mjpeg_encode_picture_header(s);

        break;

    case FMT_H261:

            ff_h261_encode_picture_header(s, picture_number);

        break;

    case FMT_H263:

            ff_wmv2_encode_picture_header(s, picture_number);

            msmpeg4_encode_picture_header(s, picture_number);

            mpeg4_encode_picture_header(s, picture_number);

            rv10_encode_picture_header(s, picture_number);

            rv20_encode_picture_header(s, picture_number);

            ff_flv_encode_picture_header(s, picture_number);

            h263_encode_picture_header(s, picture_number);

        break;

    case FMT_MPEG1:

            mpeg1_encode_picture_header(s, picture_number);

        break;

    case FMT_H264: