PeerStreamer

        ucname="`toupper $cfg`"

        if enabled $cfg; then

            echo "#define ${pfx}${ucname} 1" >> $header

            echo "${pfx}${ucname}=yes" >> $makefile

        else

            echo "#define ${pfx}${ucname} 0" >> $header

        fi

    done

}

        picture2 = picture;

    }

        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,

                           1000000 * ist->pts / AV_TIME_BASE);

#define REGISTER_ENCODER(X,x) { \

          extern AVCodec x##_encoder; \

#define REGISTER_DECODER(X,x) { \

          extern AVCodec x##_decoder; \

#define REGISTER_ENCDEC(X,x)  REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)

#define REGISTER_PARSER(X,x) { \

          extern AVCodecParser x##_parser; \

#define REGISTER_BSF(X,x) { \

          extern AVBitStreamFilter x##_bsf; \

void avcodec_register_all(void)

{

int mm_support(void)

{

}

void dsputil_init_arm(DSPContext* c, AVCodecContext *avctx)

    if(length==0) return;

        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));

    }else{

        for(i=0; put_bits_count(pb)&31; i++)

}

static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){

    int x;

    const int strength= ff_h263_loop_filter_strength[qscale];

}

static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){

    int y;

    const int strength= ff_h263_loop_filter_strength[qscale];

#endif //CONFIG_ENCODERS

    if(avctx->lowres==1){

            c->idct_put= ff_jref_idct4_put;

            c->idct_add= ff_jref_idct4_add;

        }else{

            c->idct_add= ff_jref_idct_add;

            c->idct    = j_rev_dct;

            c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;

                avctx->idct_algo==FF_IDCT_VP3){

            c->idct_put= ff_vp3_idct_put_c;

            c->idct_add= ff_vp3_idct_add_c;

            c->idct_add= ff_faanidct_add;

            c->idct    = ff_faanidct;

            c->idct_permutation_type= FF_NO_IDCT_PERM;

            c->idct_put= ff_ea_idct_put_c;

            c->idct_permutation_type= FF_NO_IDCT_PERM;

        }else{ //accurate/default

        }

    }

        c->h264_idct_add= ff_h264_idct_add_c;

        c->h264_idct8_add= ff_h264_idct8_add_c;

        c->h264_idct_dc_add= ff_h264_idct_dc_add_c;

    c->h264_h_loop_filter_chroma_intra= h264_h_loop_filter_chroma_intra_c;

    c->h264_loop_filter_strength= NULL;

        c->h263_h_loop_filter= h263_h_loop_filter_c;

        c->h263_v_loop_filter= h263_v_loop_filter_c;

    }

        c->vp3_h_loop_filter= ff_vp3_h_loop_filter_c;

        c->vp3_v_loop_filter= ff_vp3_v_loop_filter_c;

    }

    memset(c->put_2tap_qpel_pixels_tab, 0, sizeof(c->put_2tap_qpel_pixels_tab));

    memset(c->avg_2tap_qpel_pixels_tab, 0, sizeof(c->avg_2tap_qpel_pixels_tab));

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

        if(!c->put_2tap_qpel_pixels_tab[0][i])

#define TEX_VLC_BITS 9

#define DV_VLC_MAP_RUN_SIZE 15

#define DV_VLC_MAP_LEV_SIZE 23

#else

        for (i = 0; i < NB_DV_VLC - 1; i++) {

           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)

               continue;

           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)

               continue;

#endif

               dv_vlc_len[i] + (!!dv_vlc_level[i]);

        }

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

           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {

              if (dv_vlc_map[i][j].size == 0) {

                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |

    return 0;

}

/* Converts run and level (where level != 0) pair into vlc, returning bit size */

static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)

{

{

    int vo_ver_id;

    if(s->max_b_frames || s->quarter_sample){

        vo_ver_id= 5;

#include "config.h"

#include "msmpeg4.h"

#endif /* AVCODEC_H263_H */

        if (MPV_common_init(s) < 0)

            return -1;

        ff_msmpeg4_decode_init(s);

    else

        h263_decode_init_vlc(s);

    if(s->flags&CODEC_FLAG_TRUNCATED){

        int next;

            next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);

            next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

        }else{

            av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");

    }

    /* let's go :-) */

        ret= ff_wmv2_decode_picture_header(s);

        ret = msmpeg4_decode_picture_header(s);

    } else if (s->h263_pred) {

        if(s->avctx->extradata_size && s->picture_number==0){

    //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type

    //which is not available before MPV_frame_start()

        ret = ff_wmv2_decode_secondary_picture_header(s);

        if(ret<0) return ret;

        if(ret==1) goto intrax8_decoded;

    }

    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE)

            s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;

        }

        qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);

    }

    if(MB_FIELD){

        // chroma offset when predicting from a field of opposite parity

            if(!MB_MBAFF){

                *(uint64_t*)(h->top_borders[0][s->mb_x]+ 0)= *(uint64_t*)(src_y +  15*linesize);

                *(uint64_t*)(h->top_borders[0][s->mb_x]+ 8)= *(uint64_t*)(src_y +8+15*linesize);

                    *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+7*uvlinesize);

                    *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+7*uvlinesize);

                }

        }else{

            if(!MB_MBAFF){

                h->left_border[0]= h->top_borders[0][s->mb_x][15];

                    h->left_border[34   ]= h->top_borders[0][s->mb_x][16+7  ];

                    h->left_border[34+18]= h->top_borders[0][s->mb_x][16+8+7];

                }

    *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0)= *(uint64_t*)(src_y +  16*linesize);

    *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);

        h->left_border[uvoffset+34   ]= h->top_borders[top_idx][s->mb_x][16+7];

        h->left_border[uvoffset+34+18]= h->top_borders[top_idx][s->mb_x][24+7];

        for(i=1; i<9 - skiplast; i++){

        }

    }

        if(deblock_left){

            for(i = !deblock_top; i<8; i++){

                XCHG(h->left_border[uvoffset+34   +i*step], src_cb[i*uvlinesize], temp8, xchg);

    int *block_offset = &h->block_offset[0];

    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);

    /* is_h264 should always be true if SVQ3 is disabled. */

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

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

            if(h->deblocking_filter)

                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);

                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);

                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);

            }

            }

        }

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

    MpegEncContext * const s = &h->s;

    const int mb_xy= h->mb_xy;

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

        return;

    if (is_complex)

    s->mb_skip_run= -1;

    h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||

    if( h->pps.cabac ) {

        int i;

               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)

               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)

               && avctx->skip_frame < AVDISCARD_ALL){

                    static const uint8_t start_code[] = {0x00, 0x00, 0x01};

                    ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code));

                    ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed );

        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;

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

            ff_vdpau_h264_set_reference_frames(s);

        if(!s->dropable) {

        h->prev_frame_num_offset= h->frame_num_offset;

        h->prev_frame_num= h->frame_num;

            ff_vdpau_h264_picture_complete(s);

        /*

#define CHROMA 1

#endif

#endif

#define EXTENDED_SAR          255

        skip_bits(&s->gb, 8);

    if(s->lossless){

//            for(){

//            reset_ls_coding_parameters(s, 0);

                        return -1;

                    break;

                case LSE:

                        return -1;

                    break;

                case EOI:

            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,

                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);

            ptr_y = s->edge_emu_buffer;

                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;

                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,

                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);

    sy <<= 2 - lowres;

    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);

        uvsx <<= 2 - lowres;

        uvsy <<= 2 - lowres;

        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);

                my += s->mv[dir][i][1];

            }

            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);

        break;

    case MV_TYPE_FIELD:

                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);

                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);

                    if (s->chroma_y_shift){

                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);

                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);

                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);

                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);

                    if(s->chroma_y_shift){//Chroma420

                        add_dct(s, block[4], 4, dest_cb, uvlinesize);

                        add_dct(s, block[5], 5, dest_cr, uvlinesize);

                    }

                }//fi gray

            }

                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);

            }

        } else {

                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);

                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);

                    if(s->chroma_y_shift){

                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);

                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);

                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);

                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);

                    if(s->chroma_y_shift){

                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);

                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);

        }

    }

    motion_x= s->sprite_offset[1][0];

    motion_y= s->sprite_offset[1][1];

           a+1, (1<<(2*a+1)) - s->no_rounding,

           s->h_edge_pos, s->v_edge_pos);

    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;

    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;

                                src_x, src_y<<field_based,

                                s->h_edge_pos, s->v_edge_pos);

            ptr_y = s->edge_emu_buffer;

                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;

                ff_emulated_edge_mc(uvbuf ,

                                    ptr_cb, s->uvlinesize,

    pix_op[0][dxy](dest_y, ptr_y, linesize, h);

        pix_op[s->chroma_x_shift][uvdxy]

                (dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);

        pix_op[s->chroma_x_shift][uvdxy]

                (dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);

    }

         s->out_format == FMT_H261){

        ff_h261_loop_filter(s);

    }

                            17, 17+field_based, src_x, src_y<<field_based,

                            s->h_edge_pos, s->v_edge_pos);

        ptr_y= s->edge_emu_buffer;

            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;

            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize,

                                9, 9 + field_based,

        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);

        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);

    }

        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);

        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);

    }

            mx += mv[0][0];

            my += mv[0][1];

        }

            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);

        return;

                        0, 0, 0,

                        ref_picture, pix_op, qpix_op,

                        s->mv[dir][0][0], s->mv[dir][0][1], 16);

            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,

                        ref_picture, pix_op,

                        s->mv[dir][0][0], s->mv[dir][0][1], 16);

            }

        }

            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);

    }

        break;

        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:

        s->decode_mb= msmpeg4v34_decode_mb;

        break;

    case 5:

            s->decode_mb= ff_wmv2_decode_mb;

    case 6:

        //FIXME + TODO VC1 decode mb

                            int n, int coded, const uint8_t *scan_table);

int ff_wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);

#endif /* AVCODEC_MSMPEG4_H */

    c->hadamard8_diff[0] = hadamard8_diff16_altivec;

    c->hadamard8_diff[1] = hadamard8_diff8x8_altivec;

        c->vorbis_inverse_coupling = vorbis_inverse_coupling_altivec;

}

    }

#if HAVE_ALTIVEC

    if (has_altivec()) {

        mm_flags |= FF_MM_ALTIVEC;

        dsputil_init_altivec(c, avctx);

            vc1dsp_init_altivec(c, avctx);

        float_init_altivec(c, avctx);

        int_init_altivec(c, avctx);

        return -1;

    }

        avcodec_thread_free(avctx);

    if (avctx->codec->close)

        avctx->codec->close(avctx);

        "paddb %%mm1, %%mm6             \n\t"

static void h263_v_loop_filter_mmx(uint8_t *src, int stride, int qscale){

    const int strength= ff_h263_loop_filter_strength[qscale];

    __asm__ volatile(

}

static void h263_h_loop_filter_mmx(uint8_t *src, int stride, int qscale){

    const int strength= ff_h263_loop_filter_strength[qscale];

    DECLARE_ALIGNED(8, uint64_t, temp[4]);

    uint8_t *btemp= (uint8_t*)temp;

                }

                c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;

#endif

                     idct_algo==FF_IDCT_VP3){

                if(mm_flags & FF_MM_SSE2){

                    c->idct_put= ff_vp3_idct_put_sse2;

        c->draw_edges = draw_edges_mmx;

            c->h263_v_loop_filter= h263_v_loop_filter_mmx;

            c->h263_h_loop_filter= h263_h_loop_filter_mmx;

        }

                c->avg_pixels_tab[0][3] = avg_pixels16_xy2_mmx2;

                c->avg_pixels_tab[1][3] = avg_pixels8_xy2_mmx2;

                    c->vp3_v_loop_filter= ff_vp3_v_loop_filter_mmx2;

                    c->vp3_h_loop_filter= ff_vp3_h_loop_filter_mmx2;

                }

            c->biweight_h264_pixels_tab[6]= ff_h264_biweight_4x4_mmx2;

            c->biweight_h264_pixels_tab[7]= ff_h264_biweight_4x2_mmx2;

                ff_cavsdsp_init_mmx2(c, avctx);

                ff_vc1dsp_init_mmx(c, avctx);

            c->add_png_paeth_prediction= add_png_paeth_prediction_mmx2;

            c->avg_rv40_chroma_pixels_tab[0]= avg_rv40_chroma_mc8_3dnow;

            c->avg_rv40_chroma_pixels_tab[1]= avg_rv40_chroma_mc4_3dnow;

                ff_cavsdsp_init_3dnow(c, avctx);

        }

        }

    }

        dsputilenc_init_mmx(c, avctx);

#if 0

            c->sum_abs_dctelem= sum_abs_dctelem_sse2;

            c->hadamard8_diff[0]= hadamard8_diff16_sse2;

            c->hadamard8_diff[1]= hadamard8_diff_sse2;

                c->flac_compute_autocorr = ff_flac_compute_autocorr_sse2;

        }

#define REGISTER_MUXER(X,x) { \

          extern AVOutputFormat x##_muxer; \

#define REGISTER_DEMUXER(X,x) { \

          extern AVInputFormat x##_demuxer; \

#define REGISTER_MUXDEMUX(X,x)  REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)

void avdevice_register_all(void)

#include "config.h"

#include "libavformat/avformat.h"

#include <dc1394/dc1394.h>

#include <libraw1394/raw1394.h>

#include <libdc1394/dc1394_control.h>

#undef free

typedef struct dc1394_data {

    raw1394handle_t handle;

    dc1394_cameracapture camera;

    dc1394_t *d;

    dc1394camera_t *camera;

    dc1394video_frame_t *frame;

    return -1;

}

static int dc1394_v1_read_header(AVFormatContext *c, AVFormatParameters * ap)

{

    dc1394_data* dc1394 = c->priv_data;

    return 0;

}

static int dc1394_v2_read_header(AVFormatContext *c, AVFormatParameters * ap)

{

    dc1394_data* dc1394 = c->priv_data;

};

#endif

AVInputFormat libdc1394_demuxer = {

    .name           = "libdc1394",

    .long_name      = NULL_IF_CONFIG_SMALL("dc1394 v.1 A/V grab"),

#define REGISTER_FILTER(X,x,y) { \

          extern AVFilter avfilter_##y##_##x ; \

void avfilter_register_all(void)

{

#define REGISTER_MUXER(X,x) { \

    extern AVOutputFormat x##_muxer; \

#define REGISTER_DEMUXER(X,x) { \

    extern AVInputFormat x##_demuxer; \

#define REGISTER_MUXDEMUX(X,x)  REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)

#define REGISTER_PROTOCOL(X,x) { \

    extern URLProtocol x##_protocol; \

/* If you do not call this function, then you can select exactly which

   formats you want to support */

                av_freep(&s->streams[0]->codec->extradata);

                av_freep(&s->streams[0]);

                s->nb_streams = 0;

                    avi->dv_demux = dv_init_demux(s);

                    if (!avi->dv_demux)

                        goto fail;

    int64_t i, sync;

    void* dstr;

        size = dv_get_packet(avi->dv_demux, pkt);

        if (size >= 0)

            return size;

                memcpy(pkt->data + pkt->size - 4*256, ast->pal, 4*256);

        }

            dstr = pkt->destruct;

            size = dv_produce_packet(avi->dv_demux, pkt,

                                    pkt->data, pkt->size);

//    av_log(NULL, AV_LOG_DEBUG, "XX %"PRId64" %d %"PRId64"\n", timestamp, index, st->index_entries[index].timestamp);

        /* One and only one real stream for DV in AVI, and it has video  */

        /* offsets. Calling with other stream indexes should have failed */

        /* the av_index_search_timestamp call above.                     */

    int video_bitrate;

    s->packet_number = 0;

    if(ctx->packet_size)

        s->packet_size = ctx->packet_size;