typedef enum{
  TH_PF_NFORMATS
}th_pixel_fmt;
typedef struct{
  th_pixel_fmt pixel_fmt;
}th_info;
typedef struct th_comment{
}th_comment;
typedef struct{
}th_quant_info;
void oc_dequant_tables_init(short *_dequant[64][3][2],
 int _pp_dc_scale[64],const th_quant_info *_qinfo);
typedef struct oc_sb_flags oc_sb_flags;
typedef struct oc_border_info oc_border_info;
typedef struct oc_fragment oc_fragment;
typedef struct oc_theora_state oc_theora_state;
typedef signed char oc_mv[2];
struct oc_sb_flags{
  unsigned char quad_valid:4;
};
struct oc_border_info{
  long long mask;
};
struct oc_fragment{
  unsigned qii:6;
  unsigned mb_mode:3;
  signed int borderi:5;
};
struct oc_theora_state{
  th_info info;
  oc_border_info borders[16];
};
typedef void (*oc_set_chroma_mvs_func)(oc_mv _cbmvs[4],const oc_mv _lbmvs[4]);
extern const unsigned char OC_MB_MAP_NIDXS[TH_PF_NFORMATS];
extern const oc_set_chroma_mvs_func OC_SET_CHROMA_MVS_TABLE[TH_PF_NFORMATS];
struct oc_state_dispatch_vtable{
};
typedef struct oc_iquant oc_iquant;
typedef struct oc_mode_scheme_chooser oc_mode_scheme_chooser;
typedef struct th_enc_ctx oc_enc_ctx;
struct oc_mode_scheme_chooser{
  unsigned char scheme_list[8];
  int scheme_bits[8];
};
struct th_enc_ctx{
  oc_theora_state state;
  int sp_level;
  oc_mode_scheme_chooser chooser;
};
typedef struct oc_fr_state oc_fr_state;
typedef struct oc_qii_state oc_qii_state;
typedef struct oc_enc_pipeline_state oc_enc_pipeline_state;
typedef struct oc_mode_choice oc_mode_choice;
static void oc_mode_scheme_chooser_update(oc_mode_scheme_chooser *_chooser,
 int _mb_mode){
  int si;
  for(si=0;si<8;si++){
    int sj;
    int scheme0;
    int bits0;
    bits0=_chooser->scheme_bits[scheme0];
    do{
      int scheme1;
      if(bits0>=_chooser->scheme_bits[scheme1])break;
      _chooser->scheme_list[sj]=scheme1;
    }
    while(--sj>0);
  }
}
struct oc_fr_state{
  int bits;
  unsigned sb_partial_count:16;
  unsigned sb_full_count:16;
  signed int sb_partial:2;
  signed int sb_full:2;
};
static void oc_fr_state_advance_sb(oc_fr_state *_fr,
 int _sb_partial,int _sb_full){
  int sb_partial_count;
  int sb_full_count;
  if(_fr->sb_partial==_sb_partial){
    if(sb_partial_count>=4129){
    }
  }
  if(!_sb_partial){
    if(_fr->sb_full==_sb_full){
      if(sb_full_count>=4129){
      }
    }
  }
}
struct oc_qii_state{
  int bits;
  signed int qi01:2;
};
static void oc_qii_state_init(oc_qii_state *_qs){
}
struct oc_enc_pipeline_state{
  oc_fr_state fr[3];
  oc_qii_state qs[3];
  const short *dequant[3][3][2];
  const oc_iquant *enquant[3][3][2];
  unsigned *skip_ssd[3];
  int *coded_fragis[3];
  int *uncoded_fragis[3];
  int ncoded_fragis[3];
  int nuncoded_fragis[3];
  int froffset[3];
  int fragy0[3];
  int fragy_end[3];
  unsigned sbi0[3];
  unsigned sbi_end[3];
  int ndct_tokens1[3];
  int eob_run1[3];
  int loop_filter;
};
static void oc_enc_sb_transform_quantize_intra_chroma(oc_enc_ctx *_enc,
 oc_enc_pipeline_state *_pipe,int _pli,int _sbi_start,int _sbi_end){
  int sbi;
  for(sbi=_sbi_start;sbi<_sbi_end;sbi++){
  }
  oc_enc_pipeline_state pipe;
  unsigned stripe_sby;
  unsigned mcu_nvsbs;
  int notdone;
  for(stripe_sby=0;notdone;stripe_sby+=mcu_nvsbs){
    unsigned sbi_end;
    for(sbi=pipe.sbi0[0];sbi<sbi_end;sbi++){
    }
  }
}
struct oc_mode_choice{
  unsigned overhead;
  unsigned char qii[12];
};
static void oc_analyze_mb_mode_luma(oc_enc_ctx *_enc,
 const unsigned _frag_satd[12],const unsigned _skip_ssd[12],int _qti){
}
static void oc_analyze_mb_mode_chroma(oc_enc_ctx *_enc,
 const unsigned _frag_satd[12],const unsigned _skip_ssd[12],int _qti){
  unsigned cur_cost;
  int nblocks;
  int nqis;
  int pli;
  int bi;
  int qii;
  for(pli=1;pli<3;pli++){
    for(;bi<nblocks;bi++){
      unsigned best_cost;
      for(qii=1;qii<nqis;qii++){
        if(cur_cost<best_cost){
        }
      }
    }
  }
}
static void oc_skip_cost(oc_enc_ctx *_enc,oc_enc_pipeline_state *_pipe,
 unsigned _mbi,unsigned _ssd[12]){
  short buffer[64] __attribute__((aligned(16)));
  const oc_fragment *frags;
  int map_nidxs;
  long long mask;
  unsigned uncoded_ssd;
  int uncoded_dc;
  int mapii;
  int pli;
  int bi;
  int fragi;
  int borderi;
  int pi;
  for(bi=0;bi<4;bi++){
    borderi=frags[fragi].borderi;
    if(borderi<0){
      for(pi=0;pi<64;pi++){
        uncoded_ssd+=buffer[pi]*buffer[pi];
        uncoded_dc+=buffer[pi];
      }
    }
    else{
      mask=_enc->state.borders[borderi].mask;
      for(pi=0;pi<64;pi++,mask>>=1)if(mask&1){
        uncoded_ssd+=buffer[pi]*buffer[pi];
        uncoded_dc+=buffer[pi];
      }
    }
    _pipe->skip_ssd[0][fragi-_pipe->froffset[0]]=_ssd[bi]=uncoded_ssd;
  }
  mapii=4;
  for(pli=1;pli<3;pli++){
    for(;mapii<map_nidxs;mapii++){
      if(borderi<0){
        for(pi=0;pi<64;pi++){
          uncoded_ssd+=buffer[pi]*buffer[pi];
          uncoded_dc+=buffer[pi];
        }
      }
      else{
        mask=_enc->state.borders[borderi].mask;
        for(pi=0;pi<64;pi++,mask>>=1)if(mask&1){
          uncoded_ssd+=buffer[pi]*buffer[pi];
          uncoded_dc+=buffer[pi];
        }
      }
      uncoded_ssd-=uncoded_dc*uncoded_dc>>2;
      _pipe->skip_ssd[pli][fragi-_pipe->froffset[pli]]=_ssd[mapii]=uncoded_ssd;
    }
  }
}
static void oc_cost_inter4mv(oc_enc_ctx *_enc,oc_mode_choice *_modec,
 unsigned _mbi,oc_mv _mv[4],const oc_fr_state *_fr,const oc_qii_state *_qs,
 const unsigned _skip_ssd[12]){
  oc_mv lbmvs[4];
  oc_mv cbmvs[4];
  int map_nidxs;
  int mapii;
  int mv_offs[2];
  int dx=1;
  int dy=1;
  int pli=1;
  int bi;
  for(bi=0;bi<4;bi++){
  }
  (*OC_SET_CHROMA_MVS_TABLE[_enc->state.info.pixel_fmt])(cbmvs,
   (const oc_mv *)lbmvs);
  for(mapii=4;mapii<map_nidxs;mapii++){
    if(oc_state_get_mv_offsets(&_enc->state,mv_offs,pli,dx,dy)>1){
    }
  }
}
int oc_enc_analyze_inter(oc_enc_ctx *_enc,int _allow_keyframe,int _recode){
  oc_enc_pipeline_state pipe;
  oc_qii_state intra_luma_qs;
  int nmap_idxs;
  oc_sb_flags *sb_flags;
  oc_fragment *frags;
  unsigned stripe_sby;
  unsigned mcu_nvsbs;
  int notdone;
  unsigned sbi;
  unsigned sbi_end;
  nmap_idxs=OC_MB_MAP_NIDXS[_enc->state.info.pixel_fmt];
  notdone=1;
  for(stripe_sby=0;notdone;stripe_sby+=mcu_nvsbs){
    notdone=oc_enc_pipeline_set_stripe(_enc,&pipe,stripe_sby);
    sbi_end=pipe.sbi_end[0];
    for(sbi=pipe.sbi0[0];sbi<sbi_end;sbi++){
      int quadi;
      for(quadi=0;quadi<4;quadi++)if(sb_flags[sbi].quad_valid&1<<quadi){
        oc_mode_choice modes[8];
        unsigned skip_ssd[12];
        unsigned intra_satd[12];
        int mb_mode;
        unsigned mbi;
        int mapii;
        int fragi;
        if(!_recode){
          oc_cost_intra(_enc,modes+(1),mbi,
           pipe.fr+0,&intra_luma_qs,intra_satd);
        }
        oc_skip_cost(_enc,&pipe,mbi,skip_ssd);
        if(_enc->sp_level<(2)){
          oc_cost_inter4mv(_enc,modes+(7),mbi, 5, pipe.fr+0, pipe.qs+0, skip_ssd);
        }
        if(oc_enc_mb_transform_quantize_luma(_enc,&pipe,mbi,
         modes[mb_mode].overhead>>(6))>0){
          oc_mode_scheme_chooser_update(&_enc->chooser,mb_mode);
          for(mapii=4;mapii<nmap_idxs;mapii++){
            frags[fragi].mb_mode=mb_mode;
            frags[fragi].qii=modes[mb_mode].qii[mapii];
          }
        }
      }
    }
  }
}