home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wvis0626.zip / warpvision_20020626.zip / libavcodec / mpegvideo.c < prev    next >
C/C++ Source or Header  |  2002-06-24  |  94KB  |  2,612 lines
  1. /*
  2.  * The simplest mpeg encoder (well, it was the simplest!)
  3.  * Copyright (c) 2000,2001 Fabrice Bellard.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Lesser General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Lesser General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Lesser General Public
  16.  * License along with this library; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
  20.  */
  21. #include "avcodec.h"
  22. #include "dsputil.h"
  23. #include "mpegvideo.h"
  24.  
  25. #ifdef USE_FASTMEMCPY
  26. #include "fastmemcpy.h"
  27. #endif
  28.  
  29. static void encode_picture(MpegEncContext *s, int picture_number);
  30. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
  31.                                    DCTELEM *block, int n, int qscale);
  32. static void dct_unquantize_mpeg2_c(MpegEncContext *s,
  33.                                    DCTELEM *block, int n, int qscale);
  34. static void dct_unquantize_h263_c(MpegEncContext *s, 
  35.                                   DCTELEM *block, int n, int qscale);
  36. static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
  37. static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
  38.  
  39. int (*dct_quantize)(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)= dct_quantize_c;
  40. void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
  41.  
  42. #define EDGE_WIDTH 16
  43.  
  44. /* enable all paranoid tests for rounding, overflows, etc... */
  45. //#define PARANOID
  46.  
  47. //#define DEBUG
  48.  
  49.  
  50. /* for jpeg fast DCT */
  51. #define CONST_BITS 14
  52.  
  53. static const unsigned short aanscales[64] = {
  54.     /* precomputed values scaled up by 14 bits */
  55.     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  56.     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  57.     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  58.     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  59.     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  60.     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  61.     8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  62.     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  63. };
  64.  
  65. static UINT8 h263_chroma_roundtab[16] = {
  66.     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
  67. };
  68.  
  69. static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  70. static UINT8 default_fcode_tab[MAX_MV*2+1];
  71.  
  72. extern UINT8 zigzag_end[64];
  73.  
  74. /* default motion estimation */
  75. int motion_estimation_method = ME_EPZS;
  76.  
  77. static void convert_matrix(int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
  78.                            const UINT16 *quant_matrix, int bias)
  79. {
  80.     int qscale;
  81.  
  82.     for(qscale=1; qscale<32; qscale++){
  83.         int i;
  84.         if (av_fdct == fdct_ifast) {
  85.             for(i=0;i<64;i++) {
  86.                 const int j= block_permute_op(i);
  87.                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
  88.                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
  89.                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
  90.                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
  91.                 
  92.                 qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT + 11)) / 
  93.                                 (aanscales[i] * qscale * quant_matrix[j]));
  94.             }
  95.         } else {
  96.             for(i=0;i<64;i++) {
  97.                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
  98.                    So 16           <= qscale * quant_matrix[i]             <= 7905
  99.                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
  100.                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
  101.                 */
  102.                 qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
  103.                 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[block_permute_op(i)]);
  104.  
  105.                 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
  106.  
  107.                 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
  108.             }
  109.         }
  110.     }
  111. }
  112. // move into common.c perhaps 
  113. #define CHECKED_ALLOCZ(p, size)\
  114. {\
  115.     p= av_mallocz(size);\
  116.     if(p==NULL){\
  117.         perror("malloc");\
  118.         goto fail;\
  119.     }\
  120. }
  121.  
  122. /* init common structure for both encoder and decoder */
  123. int MPV_common_init(MpegEncContext *s)
  124. {
  125.     int c_size, i;
  126.     UINT8 *pict;
  127.  
  128.     s->dct_unquantize_h263 = dct_unquantize_h263_c;
  129.     s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
  130.     s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
  131.         
  132. #ifdef HAVE_MMX
  133.     MPV_common_init_mmx(s);
  134. #endif
  135.     //setup default unquantizers (mpeg4 might change it later)
  136.     if(s->out_format == FMT_H263)
  137.         s->dct_unquantize = s->dct_unquantize_h263;
  138.     else
  139.         s->dct_unquantize = s->dct_unquantize_mpeg1;
  140.     
  141.     s->mb_width = (s->width + 15) / 16;
  142.     s->mb_height = (s->height + 15) / 16;
  143.     s->mb_num = s->mb_width * s->mb_height;
  144.     s->linesize = s->mb_width * 16 + 2 * EDGE_WIDTH;
  145.  
  146.     for(i=0;i<3;i++) {
  147.         int w, h, shift, pict_start;
  148.  
  149.         w = s->linesize;
  150.         h = s->mb_height * 16 + 2 * EDGE_WIDTH;
  151.         shift = (i == 0) ? 0 : 1;
  152.         c_size = (w >> shift) * (h >> shift);
  153.         pict_start = (w >> shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
  154.  
  155.         CHECKED_ALLOCZ(pict, c_size)
  156.         s->last_picture_base[i] = pict;
  157.         s->last_picture[i] = pict + pict_start;
  158.         if(i>0) memset(s->last_picture_base[i], 128, c_size);
  159.     
  160.         CHECKED_ALLOCZ(pict, c_size)
  161.         s->next_picture_base[i] = pict;
  162.         s->next_picture[i] = pict + pict_start;
  163.         if(i>0) memset(s->next_picture_base[i], 128, c_size);
  164.         
  165.         if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
  166.         /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but 
  167.            do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
  168.             CHECKED_ALLOCZ(pict, c_size)
  169.             s->aux_picture_base[i] = pict;
  170.             s->aux_picture[i] = pict + pict_start;
  171.             if(i>0) memset(s->aux_picture_base[i], 128, c_size);
  172.         }
  173.     }
  174.     
  175.     if (s->encoding) {
  176.         int j;
  177.         int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
  178.         
  179.         CHECKED_ALLOCZ(s->mb_var   , s->mb_num * sizeof(INT16))
  180.         CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
  181.  
  182.         /* Allocate MV tables */
  183.         CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
  184.         CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
  185.         CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
  186.         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
  187.         CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
  188.         CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
  189.         CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
  190.         CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
  191.  
  192.         CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
  193.         
  194.         CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
  195.         CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
  196.  
  197.         if(s->max_b_frames){
  198.             for(j=0; j<REORDER_BUFFER_SIZE; j++){
  199.                 int i;
  200.                 for(i=0;i<3;i++) {
  201.                     int w, h, shift;
  202.  
  203.                     w = s->linesize;
  204.                     h = s->mb_height * 16;
  205.                     shift = (i == 0) ? 0 : 1;
  206.                     c_size = (w >> shift) * (h >> shift);
  207.  
  208.                     CHECKED_ALLOCZ(pict, c_size);
  209.                     s->picture_buffer[j][i] = pict;
  210.                 }
  211.             }
  212.         }
  213.  
  214.         if(s->codec_id==CODEC_ID_MPEG4){
  215.             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
  216.             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
  217.         }
  218.     }
  219.     
  220.     if (s->out_format == FMT_H263 || s->encoding) {
  221.         int size;
  222.         /* Allocate MB type table */
  223.         CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
  224.  
  225.         /* MV prediction */
  226.         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
  227.         CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
  228.     }
  229.  
  230.     if (s->h263_pred || s->h263_plus) {
  231.         int y_size, c_size, i, size;
  232.         
  233.         /* dc values */
  234.  
  235.         y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
  236.         c_size = (s->mb_width + 2) * (s->mb_height + 2);
  237.         size = y_size + 2 * c_size;
  238.         CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
  239.         s->dc_val[1] = s->dc_val[0] + y_size;
  240.         s->dc_val[2] = s->dc_val[1] + c_size;
  241.         for(i=0;i<size;i++)
  242.             s->dc_val[0][i] = 1024;
  243.  
  244.         /* ac values */
  245.         CHECKED_ALLOCZ(s->ac_val[0], size * sizeof(INT16) * 16);
  246.         s->ac_val[1] = s->ac_val[0] + y_size;
  247.         s->ac_val[2] = s->ac_val[1] + c_size;
  248.         
  249.         /* cbp values */
  250.         CHECKED_ALLOCZ(s->coded_block, y_size);
  251.  
  252.         /* which mb is a intra block */
  253.         CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
  254.         memset(s->mbintra_table, 1, s->mb_num);
  255.         
  256.         /* divx501 bitstream reorder buffer */
  257.         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
  258.         
  259.         /* cbp, ac_pred, pred_dir */
  260.         CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
  261.         CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
  262.         
  263.         CHECKED_ALLOCZ(s->qscale_table  , s->mb_num * sizeof(UINT8))
  264.     }
  265.     /* default structure is frame */
  266.     s->picture_structure = PICT_FRAME;
  267.  
  268.     /* init macroblock skip table */
  269.     CHECKED_ALLOCZ(s->mbskip_table, s->mb_num);
  270.     
  271.     s->block= s->blocks[0];
  272.  
  273.     s->context_initialized = 1;
  274.     return 0;
  275.  fail:
  276.     MPV_common_end(s);
  277.     return -1;
  278. }
  279.  
  280.  
  281. //extern int sads;
  282.  
  283. /* init common structure for both encoder and decoder */
  284. void MPV_common_end(MpegEncContext *s)
  285. {
  286.     int i;
  287.  
  288.     av_freep(&s->mb_type);
  289.     av_freep(&s->mb_var);
  290.     av_freep(&s->mc_mb_var);
  291.     av_freep(&s->p_mv_table);
  292.     av_freep(&s->b_forw_mv_table);
  293.     av_freep(&s->b_back_mv_table);
  294.     av_freep(&s->b_bidir_forw_mv_table);
  295.     av_freep(&s->b_bidir_back_mv_table);
  296.     av_freep(&s->b_direct_forw_mv_table);
  297.     av_freep(&s->b_direct_back_mv_table);
  298.     av_freep(&s->b_direct_mv_table);
  299.     av_freep(&s->motion_val);
  300.     av_freep(&s->dc_val[0]);
  301.     av_freep(&s->ac_val[0]);
  302.     av_freep(&s->coded_block);
  303.     av_freep(&s->mbintra_table);
  304.     av_freep(&s->cbp_table);
  305.     av_freep(&s->pred_dir_table);
  306.     av_freep(&s->qscale_table);
  307.     av_freep(&s->me_scratchpad);
  308.     av_freep(&s->me_map);
  309.     av_freep(&s->me_score_map);
  310.     
  311.     av_freep(&s->mbskip_table);
  312.     av_freep(&s->bitstream_buffer);
  313.     av_freep(&s->tex_pb_buffer);
  314.     av_freep(&s->pb2_buffer);
  315.     for(i=0;i<3;i++) {
  316.         int j;
  317.         av_freep(&s->last_picture_base[i]);
  318.         av_freep(&s->next_picture_base[i]);
  319.         av_freep(&s->aux_picture_base[i]);
  320.         for(j=0; j<REORDER_BUFFER_SIZE; j++){
  321.             av_freep(&s->picture_buffer[j][i]);
  322.         }
  323.     }
  324.     s->context_initialized = 0;
  325. }
  326.  
  327. /* init video encoder */
  328. int MPV_encode_init(AVCodecContext *avctx)
  329. {
  330.     MpegEncContext *s = avctx->priv_data;
  331.     int i;
  332.  
  333.     avctx->pix_fmt = PIX_FMT_YUV420P;
  334.  
  335.     s->bit_rate = avctx->bit_rate;
  336.     s->bit_rate_tolerance = avctx->bit_rate_tolerance;
  337.     s->frame_rate = avctx->frame_rate;
  338.     s->width = avctx->width;
  339.     s->height = avctx->height;
  340.     if(avctx->gop_size > 600){
  341.         fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
  342.         avctx->gop_size=600;
  343.     }
  344.     s->gop_size = avctx->gop_size;
  345.     s->rtp_mode = avctx->rtp_mode;
  346.     s->rtp_payload_size = avctx->rtp_payload_size;
  347.     if (avctx->rtp_callback)
  348.         s->rtp_callback = avctx->rtp_callback;
  349.     s->qmin= avctx->qmin;
  350.     s->qmax= avctx->qmax;
  351.     s->max_qdiff= avctx->max_qdiff;
  352.     s->qcompress= avctx->qcompress;
  353.     s->qblur= avctx->qblur;
  354.     s->b_quant_factor= avctx->b_quant_factor;
  355.     s->b_quant_offset= avctx->b_quant_offset;
  356.     s->avctx = avctx;
  357.     s->aspect_ratio_info= avctx->aspect_ratio_info;
  358.     s->flags= avctx->flags;
  359.     s->max_b_frames= avctx->max_b_frames;
  360.     s->rc_strategy= avctx->rc_strategy;
  361.     s->b_frame_strategy= avctx->b_frame_strategy;
  362.     s->codec_id= avctx->codec->id;
  363.     s->luma_elim_threshold  = avctx->luma_elim_threshold;
  364.     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
  365.     s->strict_std_compliance= avctx->strict_std_compliance;
  366.     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
  367.  
  368.     if (s->gop_size <= 1) {
  369.         s->intra_only = 1;
  370.         s->gop_size = 12;
  371.     } else {
  372.         s->intra_only = 0;
  373.     }
  374.     
  375.     /* ME algorithm */
  376.     if (avctx->me_method == 0)
  377.         /* For compatibility */
  378.         s->me_method = motion_estimation_method;
  379.     else
  380.         s->me_method = avctx->me_method;
  381.         
  382.     /* Fixed QSCALE */
  383.     s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
  384.     
  385.     switch(avctx->codec->id) {
  386.     case CODEC_ID_MPEG1VIDEO:
  387.         s->out_format = FMT_MPEG1;
  388.         avctx->delay=0; //FIXME not sure, should check the spec
  389.         break;
  390.     case CODEC_ID_MJPEG:
  391.         s->out_format = FMT_MJPEG;
  392.         s->intra_only = 1; /* force intra only for jpeg */
  393.         s->mjpeg_write_tables = 1; /* write all tables */
  394.     s->mjpeg_data_only_frames = 0; /* write all the needed headers */
  395.         s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
  396.         s->mjpeg_vsample[1] = 1; /* the only currently supported values */
  397.         s->mjpeg_vsample[2] = 1; 
  398.         s->mjpeg_hsample[0] = 2;
  399.         s->mjpeg_hsample[1] = 1; 
  400.         s->mjpeg_hsample[2] = 1; 
  401.         if (mjpeg_init(s) < 0)
  402.             return -1;
  403.         avctx->delay=0;
  404.         break;
  405.     case CODEC_ID_H263:
  406.         if (h263_get_picture_format(s->width, s->height) == 7) {
  407.             printf("Input picture size isn't suitable for h263 codec! try h263+\n");
  408.             return -1;
  409.         }
  410.         s->out_format = FMT_H263;
  411.         avctx->delay=0;
  412.         break;
  413.     case CODEC_ID_H263P:
  414.         s->out_format = FMT_H263;
  415.         s->rtp_mode = 1;
  416.         s->rtp_payload_size = 1200; 
  417.         s->h263_plus = 1;
  418.         s->unrestricted_mv = 1;
  419.         s->h263_aic = 1;
  420.         
  421.         /* These are just to be sure */
  422.         s->umvplus = 0;
  423.         s->umvplus_dec = 0;
  424.         avctx->delay=0;
  425.         break;
  426.     case CODEC_ID_RV10:
  427.         s->out_format = FMT_H263;
  428.         s->h263_rv10 = 1;
  429.         avctx->delay=0;
  430.         break;
  431.     case CODEC_ID_MPEG4:
  432.         s->out_format = FMT_H263;
  433.         s->h263_pred = 1;
  434.         s->unrestricted_mv = 1;
  435.         s->has_b_frames= s->max_b_frames ? 1 : 0;
  436.         s->low_delay=0;
  437.         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 
  438.         break;
  439.     case CODEC_ID_MSMPEG4V1:
  440.         s->out_format = FMT_H263;
  441.         s->h263_msmpeg4 = 1;
  442.         s->h263_pred = 1;
  443.         s->unrestricted_mv = 1;
  444.         s->msmpeg4_version= 1;
  445.         avctx->delay=0;
  446.         break;
  447.     case CODEC_ID_MSMPEG4V2:
  448.         s->out_format = FMT_H263;
  449.         s->h263_msmpeg4 = 1;
  450.         s->h263_pred = 1;
  451.         s->unrestricted_mv = 1;
  452.         s->msmpeg4_version= 2;
  453.         avctx->delay=0;
  454.         break;
  455.     case CODEC_ID_MSMPEG4V3:
  456.         s->out_format = FMT_H263;
  457.         s->h263_msmpeg4 = 1;
  458.         s->h263_pred = 1;
  459.         s->unrestricted_mv = 1;
  460.         s->msmpeg4_version= 3;
  461.         avctx->delay=0;
  462.         break;
  463.     case CODEC_ID_WMV1:
  464.         s->out_format = FMT_H263;
  465.         s->h263_msmpeg4 = 1;
  466.         s->h263_pred = 1;
  467.         s->unrestricted_mv = 1;
  468.         s->msmpeg4_version= 4;
  469.         avctx->delay=0;
  470.         break;
  471.     case CODEC_ID_WMV2:
  472.         s->out_format = FMT_H263;
  473.         s->h263_msmpeg4 = 1;
  474.         s->h263_pred = 1;
  475.         s->unrestricted_mv = 1;
  476.         s->msmpeg4_version= 5;
  477.         avctx->delay=0;
  478.         break;
  479.     default:
  480.         return -1;
  481.     }
  482.     
  483.     { /* set up some save defaults, some codecs might override them later */
  484.         static int done=0;
  485.         if(!done){
  486.             int i;
  487.             done=1;
  488.             memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
  489.             memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
  490.  
  491.             for(i=-16; i<16; i++){
  492.                 default_fcode_tab[i + MAX_MV]= 1;
  493.             }
  494.         }
  495.     }
  496.     s->mv_penalty= default_mv_penalty;
  497.     s->fcode_tab= default_fcode_tab;
  498.  
  499.     if (s->out_format == FMT_H263)
  500.         h263_encode_init(s);
  501.     else if (s->out_format == FMT_MPEG1)
  502.         ff_mpeg1_encode_init(s);
  503.     if(s->msmpeg4_version)
  504.         ff_msmpeg4_encode_init(s);
  505.  
  506.     /* dont use mv_penalty table for crap MV as it would be confused */
  507.     if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
  508.  
  509.     s->encoding = 1;
  510.  
  511.     /* init */
  512.     if (MPV_common_init(s) < 0)
  513.         return -1;
  514.     
  515.     /* init default q matrix */
  516.     for(i=0;i<64;i++) {
  517.         if(s->out_format == FMT_H263)
  518.             s->intra_matrix[i] = default_non_intra_matrix[i];
  519.         else
  520.             s->intra_matrix[i] = default_intra_matrix[i];
  521.  
  522.         s->inter_matrix[i] = default_non_intra_matrix[i];
  523.     }
  524.  
  525.     /* precompute matrix */
  526.     /* for mjpeg, we do include qscale in the matrix */
  527.     if (s->out_format != FMT_MJPEG) {
  528.         convert_matrix(s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
  529.                        s->intra_matrix, s->intra_quant_bias);
  530.         convert_matrix(s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
  531.                        s->inter_matrix, s->inter_quant_bias);
  532.     }
  533.  
  534.     if(ff_rate_control_init(s) < 0)
  535.         return -1;
  536.  
  537.     s->picture_number = 0;
  538.     s->picture_in_gop_number = 0;
  539.     s->fake_picture_number = 0;
  540.     /* motion detector init */
  541.     s->f_code = 1;
  542.     s->b_code = 1;
  543.  
  544.     return 0;
  545. }
  546.  
  547. int MPV_encode_end(AVCodecContext *avctx)
  548. {
  549.     MpegEncContext *s = avctx->priv_data;
  550.  
  551. #ifdef STATS
  552.     print_stats();
  553. #endif
  554.  
  555.     ff_rate_control_uninit(s);
  556.  
  557.     MPV_common_end(s);
  558.     if (s->out_format == FMT_MJPEG)
  559.         mjpeg_close(s);
  560.       
  561.     return 0;
  562. }
  563.  
  564. /* draw the edges of width 'w' of an image of size width, height */
  565. static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
  566. {
  567.     UINT8 *ptr, *last_line;
  568.     int i;
  569.  
  570.     last_line = buf + (height - 1) * wrap;
  571.     for(i=0;i<w;i++) {
  572.         /* top and bottom */
  573.         memcpy(buf - (i + 1) * wrap, buf, width);
  574.         memcpy(last_line + (i + 1) * wrap, last_line, width);
  575.     }
  576.     /* left and right */
  577.     ptr = buf;
  578.     for(i=0;i<height;i++) {
  579.         memset(ptr - w, ptr[0], w);
  580.         memset(ptr + width, ptr[width-1], w);
  581.         ptr += wrap;
  582.     }
  583.     /* corners */
  584.     for(i=0;i<w;i++) {
  585.         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
  586.         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
  587.         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
  588.         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
  589.     }
  590. }
  591.  
  592. /* generic function for encode/decode called before a frame is coded/decoded */
  593. void MPV_frame_start(MpegEncContext *s)
  594. {
  595.     int i;
  596.     UINT8 *tmp;
  597.  
  598.     s->mb_skiped = 0;
  599.     s->decoding_error=0;
  600.  
  601.     if (s->pict_type == B_TYPE) {
  602.         for(i=0;i<3;i++) {
  603.             s->current_picture[i] = s->aux_picture[i];
  604.         }
  605.     } else {
  606.         for(i=0;i<3;i++) {
  607.             /* swap next and last */
  608.             tmp = s->last_picture[i];
  609.             s->last_picture[i] = s->next_picture[i];
  610.             s->next_picture[i] = tmp;
  611.             s->current_picture[i] = tmp;
  612.         }
  613.     }
  614. }
  615.  
  616. /* generic function for encode/decode called after a frame has been coded/decoded */
  617. void MPV_frame_end(MpegEncContext *s)
  618. {
  619. //    if((s->picture_number%100)==0 && s->encoding) printf("sads:%d //\n", sads);
  620.  
  621.     /* draw edge for correct motion prediction if outside */
  622.     if (s->pict_type != B_TYPE && !s->intra_only) {
  623.       if(s->avctx==NULL || s->avctx->codec->id!=CODEC_ID_MPEG4 || s->divx_version>=500){
  624.         draw_edges(s->current_picture[0], s->linesize, s->mb_width*16, s->mb_height*16, EDGE_WIDTH);
  625.         draw_edges(s->current_picture[1], s->linesize/2, s->mb_width*8, s->mb_height*8, EDGE_WIDTH/2);
  626.         draw_edges(s->current_picture[2], s->linesize/2, s->mb_width*8, s->mb_height*8, EDGE_WIDTH/2);
  627.       }else{
  628.         /* mpeg4? / opendivx / xvid */
  629.         draw_edges(s->current_picture[0], s->linesize, s->width, s->height, EDGE_WIDTH);
  630.         draw_edges(s->current_picture[1], s->linesize/2, s->width/2, s->height/2, EDGE_WIDTH/2);
  631.         draw_edges(s->current_picture[2], s->linesize/2, s->width/2, s->height/2, EDGE_WIDTH/2);
  632.       }
  633.     }
  634.     emms_c();
  635.     
  636.     if(s->pict_type!=B_TYPE){
  637.         s->last_non_b_pict_type= s->pict_type;
  638.         s->last_non_b_qscale= s->qscale;
  639.         s->last_non_b_mc_mb_var= s->mc_mb_var_sum;
  640.         s->num_available_buffers++;
  641.         if(s->num_available_buffers>2) s->num_available_buffers= 2;
  642.     }
  643. }
  644.  
  645. /* reorder input for encoding */
  646. void reorder_input(MpegEncContext *s, AVPicture *pict)
  647. {
  648.     int i, j, index;
  649.             
  650.     if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
  651.  
  652. //        delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
  653.  
  654.     for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
  655.         s->coded_order[j]= s->coded_order[j+1];
  656.     }
  657.     s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
  658.     s->coded_order[j].pict_type=0;
  659.  
  660.     switch(s->input_pict_type){
  661.     default: 
  662.     case I_TYPE:
  663.     case S_TYPE:
  664.     case P_TYPE:
  665.         index= s->max_b_frames - s->b_frames_since_non_b;
  666.         s->b_frames_since_non_b=0;
  667.         break;            
  668.     case B_TYPE:
  669.         index= s->max_b_frames + 1;
  670.         s->b_frames_since_non_b++;
  671.         break;          
  672.     }
  673. //printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
  674.     if(   (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
  675.        && pict->linesize[0] == s->linesize
  676.        && pict->linesize[1] == s->linesize>>1
  677.        && pict->linesize[2] == s->linesize>>1){
  678. //printf("ptr\n");
  679.         for(i=0; i<3; i++){
  680.             s->coded_order[index].picture[i]= pict->data[i];
  681.         }
  682.     }else{
  683. //printf("copy\n");
  684.         for(i=0; i<3; i++){
  685.             uint8_t *src = pict->data[i];
  686.             uint8_t *dest;
  687.             int src_wrap = pict->linesize[i];
  688.             int dest_wrap = s->linesize;
  689.             int w = s->width;
  690.             int h = s->height;
  691.  
  692.             if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
  693.             else         dest= s->picture_buffer[s->picture_buffer_index][i];
  694.  
  695.             if (i >= 1) {
  696.                 dest_wrap >>= 1;
  697.                 w >>= 1;
  698.                 h >>= 1;
  699.             }
  700.  
  701.             s->coded_order[index].picture[i]= dest;
  702.             for(j=0;j<h;j++) {
  703.                 memcpy(dest, src, w);
  704.                 dest += dest_wrap;
  705.                 src += src_wrap;
  706.             }
  707.         }
  708.         if(index!=0){
  709.             s->picture_buffer_index++;
  710.             if(s->picture_buffer_index >= REORDER_BUFFER_SIZE-1) s->picture_buffer_index=0;
  711.         }
  712.     }
  713.     s->coded_order[index].pict_type = s->input_pict_type;
  714.     s->coded_order[index].qscale    = s->input_qscale;
  715.     s->coded_order[index].force_type= s->force_input_type;
  716.     s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
  717.     s->coded_order[index].picture_number= s->input_picture_number;
  718.  
  719.     for(i=0; i<3; i++){
  720.         s->new_picture[i]= s->coded_order[0].picture[i];
  721.     }
  722. }
  723.  
  724. int MPV_encode_picture(AVCodecContext *avctx,
  725.                        unsigned char *buf, int buf_size, void *data)
  726. {
  727.     MpegEncContext *s = avctx->priv_data;
  728.     AVPicture *pict = data;
  729.  
  730.     s->input_qscale = avctx->quality;
  731.  
  732.     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
  733.  
  734.     if(avctx->flags&CODEC_FLAG_TYPE){
  735.         s->input_pict_type=
  736.         s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
  737.     }else if(s->flags&CODEC_FLAG_PASS2){
  738.         s->input_pict_type=
  739.         s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
  740.     }else{
  741.         s->force_input_type=0;
  742.         if (!s->intra_only) {
  743.             /* first picture of GOP is intra */
  744.             if (s->input_picture_in_gop_number % s->gop_size==0){
  745.                 s->input_pict_type = I_TYPE;
  746.             }else if(s->max_b_frames==0){
  747.                 s->input_pict_type = P_TYPE;
  748.             }else{
  749.                 if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
  750.                     s->input_pict_type = B_TYPE;
  751.                 else
  752.                     s->input_pict_type = P_TYPE;
  753.             }
  754.         } else {
  755.             s->input_pict_type = I_TYPE;
  756.         }
  757.     }
  758.  
  759.     if(s->input_pict_type==I_TYPE)
  760.         s->input_picture_in_gop_number=0;
  761.     
  762.     reorder_input(s, pict);
  763.     
  764.     /* output? */
  765.     if(s->coded_order[0].picture[0]){
  766.  
  767.         s->pict_type= s->coded_order[0].pict_type;
  768.         if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
  769.             s->qscale= s->coded_order[0].qscale;
  770.         s->force_type= s->coded_order[0].force_type;
  771.         s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
  772.         s->picture_number= s->coded_order[0].picture_number;
  773.  
  774.         MPV_frame_start(s);
  775.  
  776.         encode_picture(s, s->picture_number);
  777.         avctx->key_frame   = (s->pict_type == I_TYPE);
  778.         avctx->pict_type   = s->pict_type;
  779.         avctx->real_pict_num  = s->picture_number;
  780.         avctx->header_bits = s->header_bits;
  781.         avctx->mv_bits     = s->mv_bits;
  782.         avctx->misc_bits   = s->misc_bits;
  783.         avctx->i_tex_bits  = s->i_tex_bits;
  784.         avctx->p_tex_bits  = s->p_tex_bits;
  785.         avctx->i_count     = s->i_count;
  786.         avctx->p_count     = s->p_count;
  787.         avctx->skip_count  = s->skip_count;
  788.  
  789.         MPV_frame_end(s);
  790.  
  791.         if (s->out_format == FMT_MJPEG)
  792.             mjpeg_picture_trailer(s);
  793.  
  794.         avctx->quality = s->qscale;
  795.         
  796.         if(s->flags&CODEC_FLAG_PASS1)
  797.             ff_write_pass1_stats(s);
  798.     
  799.     }
  800.  
  801.     s->input_picture_number++;
  802.     s->input_picture_in_gop_number++;
  803.  
  804.     flush_put_bits(&s->pb);
  805.     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
  806.     if(s->pict_type==B_TYPE) s->pb_frame_bits+= s->frame_bits;
  807.     else                     s->pb_frame_bits= s->frame_bits;
  808.  
  809.     s->total_bits += s->frame_bits;
  810.     avctx->frame_bits  = s->frame_bits;
  811. //printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", 
  812. //s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
  813.  
  814.     if (avctx->get_psnr) {
  815.         /* At this point pict->data should have the original frame   */
  816.         /* an s->current_picture should have the coded/decoded frame */
  817.         get_psnr(pict->data, s->current_picture,
  818.                  pict->linesize, s->linesize, avctx);
  819. //        printf("%f\n", avctx->psnr_y);
  820.     }
  821.     return pbBufPtr(&s->pb) - s->pb.buf;
  822. }
  823.  
  824. static inline void gmc1_motion(MpegEncContext *s,
  825.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
  826.                                int dest_offset,
  827.                                UINT8 **ref_picture, int src_offset,
  828.                                int h)
  829. {
  830.     UINT8 *ptr;
  831.     int offset, src_x, src_y, linesize;
  832.     int motion_x, motion_y;
  833.  
  834.     if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
  835.     motion_x= s->sprite_offset[0][0];
  836.     motion_y= s->sprite_offset[0][1];
  837.     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
  838.     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
  839.     motion_x<<=(3-s->sprite_warping_accuracy);
  840.     motion_y<<=(3-s->sprite_warping_accuracy);
  841.     src_x = clip(src_x, -16, s->width);
  842.     if (src_x == s->width)
  843.         motion_x =0;
  844.     src_y = clip(src_y, -16, s->height);
  845.     if (src_y == s->height)
  846.         motion_y =0;
  847.     
  848.     linesize = s->linesize;
  849.     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
  850.  
  851.     dest_y+=dest_offset;
  852.     gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
  853.     gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
  854.  
  855.     motion_x= s->sprite_offset[1][0];
  856.     motion_y= s->sprite_offset[1][1];
  857.     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
  858.     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
  859.     motion_x<<=(3-s->sprite_warping_accuracy);
  860.     motion_y<<=(3-s->sprite_warping_accuracy);
  861.     src_x = clip(src_x, -8, s->width>>1);
  862.     if (src_x == s->width>>1)
  863.         motion_x =0;
  864.     src_y = clip(src_y, -8, s->height>>1);
  865.     if (src_y == s->height>>1)
  866.         motion_y =0;
  867.  
  868.     offset = (src_y * linesize>>1) + src_x + (src_offset>>1);
  869.     ptr = ref_picture[1] + offset;
  870.     gmc1(dest_cb + (dest_offset>>1), ptr, linesize>>1, h>>1, motion_x&15, motion_y&15, s->no_rounding);
  871.     ptr = ref_picture[2] + offset;
  872.     gmc1(dest_cr + (dest_offset>>1), ptr, linesize>>1, h>>1, motion_x&15, motion_y&15, s->no_rounding);
  873.     
  874.     return;
  875. }
  876.  
  877. /* apply one mpeg motion vector to the three components */
  878. static inline void mpeg_motion(MpegEncContext *s,
  879.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
  880.                                int dest_offset,
  881.                                UINT8 **ref_picture, int src_offset,
  882.                                int field_based, op_pixels_func *pix_op,
  883.                                int motion_x, int motion_y, int h)
  884. {
  885.     UINT8 *ptr;
  886.     int dxy, offset, mx, my, src_x, src_y, height, linesize;
  887. if(s->quarter_sample)
  888. {
  889.     motion_x>>=1;
  890.     motion_y>>=1;
  891. }
  892.     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
  893.     src_x = s->mb_x * 16 + (motion_x >> 1);
  894.     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
  895.                 
  896.     /* WARNING: do no forget half pels */
  897.     height = s->height >> field_based;
  898.     src_x = clip(src_x, -16, s->width);
  899.     if (src_x == s->width)
  900.         dxy &= ~1;
  901.     src_y = clip(src_y, -16, height);
  902.     if (src_y == height)
  903.         dxy &= ~2;
  904.     linesize = s->linesize << field_based;
  905.     ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
  906.     dest_y += dest_offset;
  907.     pix_op[dxy](dest_y, ptr, linesize, h);
  908.     pix_op[dxy](dest_y + 8, ptr + 8, linesize, h);
  909.  
  910.     if(s->flags&CODEC_FLAG_GRAY) return;
  911.  
  912.     if (s->out_format == FMT_H263) {
  913.         dxy = 0;
  914.         if ((motion_x & 3) != 0)
  915.             dxy |= 1;
  916.         if ((motion_y & 3) != 0)
  917.             dxy |= 2;
  918.         mx = motion_x >> 2;
  919.         my = motion_y >> 2;
  920.     } else {
  921.         mx = motion_x / 2;
  922.         my = motion_y / 2;
  923.         dxy = ((my & 1) << 1) | (mx & 1);
  924.         mx >>= 1;
  925.         my >>= 1;
  926.     }
  927.     
  928.     src_x = s->mb_x * 8 + mx;
  929.     src_y = s->mb_y * (8 >> field_based) + my;
  930.     src_x = clip(src_x, -8, s->width >> 1);
  931.     if (src_x == (s->width >> 1))
  932.         dxy &= ~1;
  933.     src_y = clip(src_y, -8, height >> 1);
  934.     if (src_y == (height >> 1))
  935.         dxy &= ~2;
  936.  
  937.     offset = (src_y * (linesize >> 1)) + src_x + (src_offset >> 1);
  938.     ptr = ref_picture[1] + offset;
  939.     pix_op[dxy](dest_cb + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);
  940.     ptr = ref_picture[2] + offset;
  941.     pix_op[dxy](dest_cr + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);
  942. }
  943.  
  944. static inline void qpel_motion(MpegEncContext *s,
  945.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
  946.                                int dest_offset,
  947.                                UINT8 **ref_picture, int src_offset,
  948.                                int field_based, op_pixels_func *pix_op,
  949.                                qpel_mc_func *qpix_op,
  950.                                int motion_x, int motion_y, int h)
  951. {
  952.     UINT8 *ptr;
  953.     int dxy, offset, mx, my, src_x, src_y, height, linesize;
  954.  
  955.     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
  956.     src_x = s->mb_x * 16 + (motion_x >> 2);
  957.     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
  958.  
  959.     height = s->height >> field_based;
  960.     src_x = clip(src_x, -16, s->width);
  961.     if (src_x == s->width)
  962.         dxy &= ~3;
  963.     src_y = clip(src_y, -16, height);
  964.     if (src_y == height)
  965.         dxy &= ~12;
  966.     linesize = s->linesize << field_based;
  967.     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
  968.     dest_y += dest_offset;
  969. //printf("%d %d %d\n", src_x, src_y, dxy);
  970.     qpix_op[dxy](dest_y                 , ptr                 , linesize, linesize, motion_x&3, motion_y&3);
  971.     qpix_op[dxy](dest_y              + 8, ptr              + 8, linesize, linesize, motion_x&3, motion_y&3);
  972.     qpix_op[dxy](dest_y + linesize*8    , ptr + linesize*8    , linesize, linesize, motion_x&3, motion_y&3);
  973.     qpix_op[dxy](dest_y + linesize*8 + 8, ptr + linesize*8 + 8, linesize, linesize, motion_x&3, motion_y&3);
  974.     
  975.     if(s->flags&CODEC_FLAG_GRAY) return;
  976.  
  977.     mx= (motion_x>>1) | (motion_x&1);
  978.     my= (motion_y>>1) | (motion_y&1);
  979.  
  980.     dxy = 0;
  981.     if ((mx & 3) != 0)
  982.         dxy |= 1;
  983.     if ((my & 3) != 0)
  984.         dxy |= 2;
  985.     mx = mx >> 2;
  986.     my = my >> 2;
  987.     
  988.     src_x = s->mb_x * 8 + mx;
  989.     src_y = s->mb_y * (8 >> field_based) + my;
  990.     src_x = clip(src_x, -8, s->width >> 1);
  991.     if (src_x == (s->width >> 1))
  992.         dxy &= ~1;
  993.     src_y = clip(src_y, -8, height >> 1);
  994.     if (src_y == (height >> 1))
  995.         dxy &= ~2;
  996.  
  997.     offset = (src_y * (linesize >> 1)) + src_x + (src_offset >> 1);
  998.     ptr = ref_picture[1] + offset;
  999.     pix_op[dxy](dest_cb + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);
  1000.     ptr = ref_picture[2] + offset;
  1001.     pix_op[dxy](dest_cr + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);
  1002. }
  1003.  
  1004.  
  1005. static inline void MPV_motion(MpegEncContext *s, 
  1006.                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
  1007.                               int dir, UINT8 **ref_picture, 
  1008.                               op_pixels_func *pix_op, qpel_mc_func *qpix_op)
  1009. {
  1010.     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
  1011.     int mb_x, mb_y, i;
  1012.     UINT8 *ptr, *dest;
  1013.  
  1014.     mb_x = s->mb_x;
  1015.     mb_y = s->mb_y;
  1016.  
  1017.     switch(s->mv_type) {
  1018.     case MV_TYPE_16X16:
  1019.         if(s->mcsel){
  1020. #if 0
  1021.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
  1022.                         ref_picture, 0,
  1023.                         0, pix_op,
  1024.                         s->sprite_offset[0][0]>>3,
  1025.                         s->sprite_offset[0][1]>>3,
  1026.                         16);
  1027. #else
  1028.             gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
  1029.                         ref_picture, 0,
  1030.                         16);
  1031. #endif
  1032.         }else if(s->quarter_sample && dir==0){ //FIXME
  1033.             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
  1034.                         ref_picture, 0,
  1035.                         0, pix_op, qpix_op,
  1036.                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
  1037.         }else{
  1038.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
  1039.                         ref_picture, 0,
  1040.                         0, pix_op,
  1041.                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
  1042.         }           
  1043.         break;
  1044.     case MV_TYPE_8X8:
  1045.         for(i=0;i<4;i++) {
  1046.             motion_x = s->mv[dir][i][0];
  1047.             motion_y = s->mv[dir][i][1];
  1048.  
  1049.             dxy = ((motion_y & 1) << 1) | (motion_x & 1);
  1050.             src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
  1051.             src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
  1052.                     
  1053.             /* WARNING: do no forget half pels */
  1054.             src_x = clip(src_x, -16, s->width);
  1055.             if (src_x == s->width)
  1056.                 dxy &= ~1;
  1057.             src_y = clip(src_y, -16, s->height);
  1058.             if (src_y == s->height)
  1059.                 dxy &= ~2;
  1060.                     
  1061.             ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
  1062.             dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
  1063.             pix_op[dxy](dest, ptr, s->linesize, 8);
  1064.         }
  1065.     
  1066.         if(s->flags&CODEC_FLAG_GRAY) break;
  1067.         /* In case of 8X8, we construct a single chroma motion vector
  1068.            with a special rounding */
  1069.         mx = 0;
  1070.         my = 0;
  1071.         for(i=0;i<4;i++) {
  1072.             mx += s->mv[dir][i][0];
  1073.             my += s->mv[dir][i][1];
  1074.         }
  1075.         if (mx >= 0)
  1076.             mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
  1077.         else {
  1078.             mx = -mx;
  1079.             mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
  1080.         }
  1081.         if (my >= 0)
  1082.             my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
  1083.         else {
  1084.             my = -my;
  1085.             my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
  1086.         }
  1087.         dxy = ((my & 1) << 1) | (mx & 1);
  1088.         mx >>= 1;
  1089.         my >>= 1;
  1090.  
  1091.         src_x = mb_x * 8 + mx;
  1092.         src_y = mb_y * 8 + my;
  1093.         src_x = clip(src_x, -8, s->width/2);
  1094.         if (src_x == s->width/2)
  1095.             dxy &= ~1;
  1096.         src_y = clip(src_y, -8, s->height/2);
  1097.         if (src_y == s->height/2)
  1098.             dxy &= ~2;
  1099.         
  1100.         offset = (src_y * (s->linesize >> 1)) + src_x;
  1101.         ptr = ref_picture[1] + offset;
  1102.         pix_op[dxy](dest_cb, ptr, s->linesize >> 1, 8);
  1103.         ptr = ref_picture[2] + offset;
  1104.         pix_op[dxy](dest_cr, ptr, s->linesize >> 1, 8);
  1105.         break;
  1106.     case MV_TYPE_FIELD:
  1107.         if (s->picture_structure == PICT_FRAME) {
  1108.             /* top field */
  1109.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
  1110.                         ref_picture, s->field_select[dir][0] ? s->linesize : 0,
  1111.                         1, pix_op,
  1112.                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
  1113.             /* bottom field */
  1114.             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
  1115.                         ref_picture, s->field_select[dir][1] ? s->linesize : 0,
  1116.                         1, pix_op,
  1117.                         s->mv[dir][1][0], s->mv[dir][1][1], 8);
  1118.         } else {
  1119.             
  1120.  
  1121.         }
  1122.         break;
  1123.     }
  1124. }
  1125.  
  1126.  
  1127. /* put block[] to dest[] */
  1128. static inline void put_dct(MpegEncContext *s, 
  1129.                            DCTELEM *block, int i, UINT8 *dest, int line_size)
  1130. {
  1131.     if (!s->mpeg2)
  1132.         s->dct_unquantize(s, block, i, s->qscale);
  1133.     ff_idct_put (dest, line_size, block);
  1134. }
  1135.  
  1136. /* add block[] to dest[] */
  1137. static inline void add_dct(MpegEncContext *s, 
  1138.                            DCTELEM *block, int i, UINT8 *dest, int line_size)
  1139. {
  1140.     if (s->block_last_index[i] >= 0) {
  1141.         ff_idct_add (dest, line_size, block);
  1142.     }
  1143. }
  1144.  
  1145. static inline void add_dequant_dct(MpegEncContext *s, 
  1146.                            DCTELEM *block, int i, UINT8 *dest, int line_size)
  1147. {
  1148.     if (s->block_last_index[i] >= 0) {
  1149.         s->dct_unquantize(s, block, i, s->qscale);
  1150.  
  1151.         ff_idct_add (dest, line_size, block);
  1152.     }
  1153. }
  1154.  
  1155. /**
  1156.  * cleans dc, ac, coded_block for the current non intra MB
  1157.  */
  1158. void ff_clean_intra_table_entries(MpegEncContext *s)
  1159. {
  1160.     int wrap = s->block_wrap[0];
  1161.     int xy = s->block_index[0];
  1162.     
  1163.     s->dc_val[0][xy           ] = 
  1164.     s->dc_val[0][xy + 1       ] = 
  1165.     s->dc_val[0][xy     + wrap] =
  1166.     s->dc_val[0][xy + 1 + wrap] = 1024;
  1167.     /* ac pred */
  1168.     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
  1169.     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
  1170.     if (s->msmpeg4_version>=3) {
  1171.         s->coded_block[xy           ] =
  1172.         s->coded_block[xy + 1       ] =
  1173.         s->coded_block[xy     + wrap] =
  1174.         s->coded_block[xy + 1 + wrap] = 0;
  1175.     }
  1176.     /* chroma */
  1177.     wrap = s->block_wrap[4];
  1178.     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
  1179.     s->dc_val[1][xy] =
  1180.     s->dc_val[2][xy] = 1024;
  1181.     /* ac pred */
  1182.     memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
  1183.     memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
  1184.     
  1185.     s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
  1186. }
  1187.  
  1188. /* generic function called after a macroblock has been parsed by the
  1189.    decoder or after it has been encoded by the encoder.
  1190.  
  1191.    Important variables used:
  1192.    s->mb_intra : true if intra macroblock
  1193.    s->mv_dir   : motion vector direction
  1194.    s->mv_type  : motion vector type
  1195.    s->mv       : motion vector
  1196.    s->interlaced_dct : true if interlaced dct used (mpeg2)
  1197.  */
  1198. void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
  1199. {
  1200.     int mb_x, mb_y;
  1201.     const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
  1202.  
  1203.     mb_x = s->mb_x;
  1204.     mb_y = s->mb_y;
  1205.  
  1206. #ifdef FF_POSTPROCESS
  1207.     /* Obsolete. Exists for compatibility with mplayer only. */
  1208.     quant_store[mb_y][mb_x]=s->qscale;
  1209.     //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
  1210. #else
  1211.     if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
  1212. #endif
  1213.  
  1214.     /* update DC predictors for P macroblocks */
  1215.     if (!s->mb_intra) {
  1216.         if (s->h263_pred || s->h263_aic) {
  1217.             if(s->mbintra_table[mb_xy])
  1218.                 ff_clean_intra_table_entries(s);
  1219.         } else {
  1220.             s->last_dc[0] =
  1221.             s->last_dc[1] =
  1222.             s->last_dc[2] = 128 << s->intra_dc_precision;
  1223.         }
  1224.     }
  1225.     else if (s->h263_pred || s->h263_aic)
  1226.         s->mbintra_table[mb_xy]=1;
  1227.  
  1228.     /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
  1229.     if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
  1230.         int motion_x, motion_y;
  1231.         
  1232.         const int wrap = s->block_wrap[0];
  1233.         const int xy = s->block_index[0];
  1234.         if (s->mb_intra) {
  1235.             motion_x = 0;
  1236.             motion_y = 0;
  1237.             goto motion_init;
  1238.         } else if (s->mv_type == MV_TYPE_16X16) {
  1239.             motion_x = s->mv[0][0][0];
  1240.             motion_y = s->mv[0][0][1];
  1241.         motion_init:
  1242.             /* no update if 8X8 because it has been done during parsing */
  1243.             s->motion_val[xy][0] = motion_x;
  1244.             s->motion_val[xy][1] = motion_y;
  1245.             s->motion_val[xy + 1][0] = motion_x;
  1246.             s->motion_val[xy + 1][1] = motion_y;
  1247.             s->motion_val[xy + wrap][0] = motion_x;
  1248.             s->motion_val[xy + wrap][1] = motion_y;
  1249.             s->motion_val[xy + 1 + wrap][0] = motion_x;
  1250.             s->motion_val[xy + 1 + wrap][1] = motion_y;
  1251.         }
  1252.     }
  1253.     
  1254.     if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
  1255.         UINT8 *dest_y, *dest_cb, *dest_cr;
  1256.         int dct_linesize, dct_offset;
  1257.         op_pixels_func *op_pix;
  1258.         qpel_mc_func *op_qpix;
  1259.  
  1260.         /* avoid copy if macroblock skipped in last frame too 
  1261.            dont touch it for B-frames as they need the skip info from the next p-frame */
  1262.         if (s->pict_type != B_TYPE) {
  1263.             UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
  1264.             if (s->mb_skiped) {
  1265.                 s->mb_skiped = 0;
  1266.                 /* if previous was skipped too, then nothing to do ! 
  1267.                    skip only during decoding as we might trash the buffers during encoding a bit */
  1268.                 if (*mbskip_ptr != 0 && !s->encoding) 
  1269.                     goto the_end;
  1270.                 *mbskip_ptr = 1; /* indicate that this time we skiped it */
  1271.             } else {
  1272.                 *mbskip_ptr = 0; /* not skipped */
  1273.             }
  1274.         }
  1275.  
  1276.         dest_y = s->current_picture[0] + (mb_y * 16 * s->linesize) + mb_x * 16;
  1277.         dest_cb = s->current_picture[1] + (mb_y * 8 * (s->linesize >> 1)) + mb_x * 8;
  1278.         dest_cr = s->current_picture[2] + (mb_y * 8 * (s->linesize >> 1)) + mb_x * 8;
  1279.  
  1280.         if (s->interlaced_dct) {
  1281.             dct_linesize = s->linesize * 2;
  1282.             dct_offset = s->linesize;
  1283.         } else {
  1284.             dct_linesize = s->linesize;
  1285.             dct_offset = s->linesize * 8;
  1286.         }
  1287.  
  1288.         if (!s->mb_intra) {
  1289.             /* motion handling */
  1290.             /* decoding or more than one mb_type (MC was allready done otherwise) */
  1291.             if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
  1292.                 if ((!s->no_rounding) || s->pict_type==B_TYPE){                
  1293.                     op_pix = put_pixels_tab;
  1294.                     op_qpix= qpel_mc_rnd_tab;
  1295.                 }else{
  1296.                     op_pix = put_no_rnd_pixels_tab;
  1297.                     op_qpix= qpel_mc_no_rnd_tab;
  1298.                 }
  1299.  
  1300.                 if (s->mv_dir & MV_DIR_FORWARD) {
  1301.                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
  1302.                     if ((!s->no_rounding) || s->pict_type==B_TYPE)
  1303.                         op_pix = avg_pixels_tab;
  1304.                     else
  1305.                         op_pix = avg_no_rnd_pixels_tab;
  1306.                 }
  1307.                 if (s->mv_dir & MV_DIR_BACKWARD) {
  1308.                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
  1309.                 }
  1310.             }
  1311.  
  1312.             /* skip dequant / idct if we are really late ;) */
  1313.             if(s->hurry_up>1) goto the_end;
  1314.  
  1315.             /* add dct residue */
  1316.             if(!s->mpeg2 && (s->encoding || (!s->h263_msmpeg4))){
  1317.                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
  1318.                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
  1319.                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
  1320.                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
  1321.  
  1322.                 if(!(s->flags&CODEC_FLAG_GRAY)){
  1323.                     add_dequant_dct(s, block[4], 4, dest_cb, s->linesize >> 1);
  1324.                     add_dequant_dct(s, block[5], 5, dest_cr, s->linesize >> 1);
  1325.                 }
  1326.             } else {
  1327.                 add_dct(s, block[0], 0, dest_y, dct_linesize);
  1328.                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
  1329.                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
  1330.                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
  1331.  
  1332.                 if(!(s->flags&CODEC_FLAG_GRAY)){
  1333.                     add_dct(s, block[4], 4, dest_cb, s->linesize >> 1);
  1334.                     add_dct(s, block[5], 5, dest_cr, s->linesize >> 1);
  1335.                 }
  1336.             }
  1337.         } else {
  1338.             /* dct only in intra block */
  1339.             put_dct(s, block[0], 0, dest_y, dct_linesize);
  1340.             put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
  1341.             put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
  1342.             put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
  1343.  
  1344.             if(!(s->flags&CODEC_FLAG_GRAY)){
  1345.                 put_dct(s, block[4], 4, dest_cb, s->linesize >> 1);
  1346.                 put_dct(s, block[5], 5, dest_cr, s->linesize >> 1);
  1347.             }
  1348.         }
  1349.     }
  1350.  the_end:
  1351.     emms_c(); //FIXME remove
  1352. }
  1353.  
  1354. static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold, int skip_dc)
  1355. {
  1356.     static const char tab[64]=
  1357.         {3,2,2,1,1,1,1,1,
  1358.          1,1,1,1,1,1,1,1,
  1359.          1,1,1,1,1,1,1,1,
  1360.          0,0,0,0,0,0,0,0,
  1361.          0,0,0,0,0,0,0,0,
  1362.          0,0,0,0,0,0,0,0,
  1363.          0,0,0,0,0,0,0,0,
  1364.          0,0,0,0,0,0,0,0};
  1365.     int score=0;
  1366.     int run=0;
  1367.     int i;
  1368.     DCTELEM *block= s->block[n];
  1369.     const int last_index= s->block_last_index[n];
  1370.  
  1371.     if(skip_dc) skip_dc=1;
  1372.     
  1373.     /* are all which we could set to zero are allready zero? */
  1374.     if(last_index<=skip_dc - 1) return;
  1375.  
  1376.     for(i=0; i<=last_index; i++){
  1377.         const int j = zigzag_direct[i];
  1378.         const int level = ABS(block[j]);
  1379.         if(level==1){
  1380.             if(skip_dc && i==0) continue;
  1381.             score+= tab[run];
  1382.             run=0;
  1383.         }else if(level>1){
  1384.             return;
  1385.         }else{
  1386.             run++;
  1387.         }
  1388.     }
  1389.     if(score >= threshold) return;
  1390.     for(i=skip_dc; i<=last_index; i++){
  1391.         const int j = zigzag_direct[i];
  1392.         block[j]=0;
  1393.     }
  1394.     if(block[0]) s->block_last_index[n]= 0;
  1395.     else         s->block_last_index[n]= -1;
  1396. }
  1397.  
  1398. static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
  1399. {
  1400.     int i;
  1401.     const int maxlevel= s->max_qcoeff;
  1402.     const int minlevel= s->min_qcoeff;
  1403.         
  1404.     for(i=0;i<=last_index; i++){
  1405.         const int j = zigzag_direct[i];
  1406.         int level = block[j];
  1407.        
  1408.         if     (level>maxlevel) level=maxlevel;
  1409.         else if(level<minlevel) level=minlevel;
  1410.         block[j]= level;
  1411.     }
  1412. }
  1413.  
  1414. static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
  1415. {
  1416.     const int mb_x= s->mb_x;
  1417.     const int mb_y= s->mb_y;
  1418.     int i;
  1419.     int skip_dct[6];
  1420. #if 0
  1421.         if (s->interlaced_dct) {
  1422.             dct_linesize = s->linesize * 2;
  1423.             dct_offset = s->linesize;
  1424.         } else {
  1425.             dct_linesize = s->linesize;
  1426.             dct_offset = s->linesize * 8;
  1427.         }
  1428. #endif
  1429.     for(i=0; i<6; i++) skip_dct[i]=0;
  1430.  
  1431.     if (s->mb_intra) {
  1432.         UINT8 *ptr;
  1433.         int wrap;
  1434.  
  1435.         wrap = s->linesize;
  1436.         ptr = s->new_picture[0] + (mb_y * 16 * wrap) + mb_x * 16;
  1437.         get_pixels(s->block[0], ptr               , wrap);
  1438.         get_pixels(s->block[1], ptr            + 8, wrap);
  1439.         get_pixels(s->block[2], ptr + 8 * wrap    , wrap);
  1440.         get_pixels(s->block[3], ptr + 8 * wrap + 8, wrap);
  1441.  
  1442.         if(s->flags&CODEC_FLAG_GRAY){
  1443.             skip_dct[4]= 1;
  1444.             skip_dct[5]= 1;
  1445.         }else{
  1446.             wrap >>=1;
  1447.             ptr = s->new_picture[1] + (mb_y * 8 * wrap) + mb_x * 8;
  1448.             get_pixels(s->block[4], ptr, wrap);
  1449.  
  1450.             ptr = s->new_picture[2] + (mb_y * 8 * wrap) + mb_x * 8;
  1451.             get_pixels(s->block[5], ptr, wrap);
  1452.         }
  1453.     }else{
  1454.         op_pixels_func *op_pix;
  1455.         qpel_mc_func *op_qpix;
  1456.         UINT8 *dest_y, *dest_cb, *dest_cr;
  1457.         UINT8 *ptr_y, *ptr_cb, *ptr_cr;
  1458.         int wrap_y, wrap_c;
  1459.  
  1460.         dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
  1461.         dest_cb = s->current_picture[1] + (mb_y * 8  * (s->linesize >> 1)) + mb_x * 8;
  1462.         dest_cr = s->current_picture[2] + (mb_y * 8  * (s->linesize >> 1)) + mb_x * 8;
  1463.         wrap_y = s->linesize;
  1464.         wrap_c = wrap_y>>1;
  1465.         ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
  1466.         ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
  1467.         ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
  1468.  
  1469.         if ((!s->no_rounding) || s->pict_type==B_TYPE){
  1470.             op_pix = put_pixels_tab;
  1471.             op_qpix= qpel_mc_rnd_tab;
  1472.         }else{
  1473.             op_pix = put_no_rnd_pixels_tab;
  1474.             op_qpix= qpel_mc_no_rnd_tab;
  1475.         }
  1476.  
  1477.         if (s->mv_dir & MV_DIR_FORWARD) {
  1478.             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
  1479.            if ((!s->no_rounding) || s->pict_type==B_TYPE)
  1480.                 op_pix = avg_pixels_tab;
  1481.             else
  1482.                 op_pix = avg_no_rnd_pixels_tab;
  1483.         }
  1484.         if (s->mv_dir & MV_DIR_BACKWARD) {
  1485.             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
  1486.         }
  1487.  
  1488.         diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
  1489.         diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
  1490.         diff_pixels(s->block[2], ptr_y + 8 * wrap_y    , dest_y + 8 * wrap_y    , wrap_y);
  1491.         diff_pixels(s->block[3], ptr_y + 8 * wrap_y + 8, dest_y + 8 * wrap_y + 8, wrap_y);
  1492.         
  1493.         if(s->flags&CODEC_FLAG_GRAY){
  1494.             skip_dct[4]= 1;
  1495.             skip_dct[5]= 1;
  1496.         }else{
  1497.             diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
  1498.             diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
  1499.         }
  1500.  
  1501.         /* pre quantization */         
  1502.         if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
  1503.             if(pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
  1504.             if(pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
  1505.             if(pix_abs8x8(ptr_y + 8*wrap_y    , dest_y + 8*wrap_y    , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
  1506.             if(pix_abs8x8(ptr_y + 8*wrap_y + 8, dest_y + 8*wrap_y + 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
  1507.             if(pix_abs8x8(ptr_cb              , dest_cb              , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
  1508.             if(pix_abs8x8(ptr_cr              , dest_cr              , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
  1509. #if 0
  1510. {
  1511.  static int stat[7];
  1512.  int num=0;
  1513.  for(i=0; i<6; i++)
  1514.   if(skip_dct[i]) num++;
  1515.  stat[num]++;
  1516.  
  1517.  if(s->mb_x==0 && s->mb_y==0){
  1518.   for(i=0; i<7; i++){
  1519.    printf("%6d %1d\n", stat[i], i);
  1520.   }
  1521.  }
  1522. }
  1523. #endif
  1524.         }
  1525.  
  1526.     }
  1527.             
  1528. #if 0
  1529.             {
  1530.                 float adap_parm;
  1531.                 
  1532.                 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
  1533.                             ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
  1534.             
  1535.                 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
  1536.                         (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
  1537.                         s->qscale, adap_parm, s->qscale*adap_parm,
  1538.                         s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
  1539.             }
  1540. #endif
  1541.     /* DCT & quantize */
  1542.     if(s->out_format==FMT_MJPEG){
  1543.         for(i=0;i<6;i++) {
  1544.             int overflow;
  1545.             s->block_last_index[i] = dct_quantize(s, s->block[i], i, 8, &overflow);
  1546.             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
  1547.         }
  1548.     }else{
  1549.         for(i=0;i<6;i++) {
  1550.             if(!skip_dct[i]){
  1551.                 int overflow;
  1552.                 s->block_last_index[i] = dct_quantize(s, s->block[i], i, s->qscale, &overflow);
  1553.             // FIXME we could decide to change to quantizer instead of clipping
  1554.             // JS: I don't think that would be a good idea it could lower quality instead
  1555.             //     of improve it. Just INTRADC clipping deserves changes in quantizer
  1556.                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
  1557.             }else
  1558.                 s->block_last_index[i]= -1;
  1559.         }
  1560.         if(s->luma_elim_threshold && !s->mb_intra)
  1561.             for(i=0; i<4; i++)
  1562.                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold, 0);
  1563.         if(s->chroma_elim_threshold && !s->mb_intra)
  1564.             for(i=4; i<6; i++)
  1565.                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold, 1);
  1566.     }
  1567.  
  1568.     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
  1569.         s->block_last_index[4]=
  1570.         s->block_last_index[5]= 0;
  1571.         s->block[4][0]=
  1572.         s->block[5][0]= 128;
  1573.     }
  1574.  
  1575.     /* huffman encode */
  1576.     switch(s->out_format) {
  1577.     case FMT_MPEG1:
  1578.         mpeg1_encode_mb(s, s->block, motion_x, motion_y);
  1579.         break;
  1580.     case FMT_H263:
  1581.         if (s->h263_msmpeg4)
  1582.             msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
  1583.         else if(s->h263_pred)
  1584.             mpeg4_encode_mb(s, s->block, motion_x, motion_y);
  1585.         else
  1586.             h263_encode_mb(s, s->block, motion_x, motion_y);
  1587.         break;
  1588.     case FMT_MJPEG:
  1589.         mjpeg_encode_mb(s, s->block);
  1590.         break;
  1591.     }
  1592. }
  1593.  
  1594. void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
  1595. {
  1596.     int bytes= length>>4;
  1597.     int bits= length&15;
  1598.     int i;
  1599.  
  1600.     if(length==0) return;
  1601.  
  1602.     for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
  1603.     put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
  1604. }
  1605.  
  1606. static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
  1607.     int i;
  1608.  
  1609.     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
  1610.  
  1611.     /* mpeg1 */
  1612.     d->mb_incr= s->mb_incr;
  1613.     for(i=0; i<3; i++)
  1614.         d->last_dc[i]= s->last_dc[i];
  1615.     
  1616.     /* statistics */
  1617.     d->mv_bits= s->mv_bits;
  1618.     d->i_tex_bits= s->i_tex_bits;
  1619.     d->p_tex_bits= s->p_tex_bits;
  1620.     d->i_count= s->i_count;
  1621.     d->p_count= s->p_count;
  1622.     d->skip_count= s->skip_count;
  1623.     d->misc_bits= s->misc_bits;
  1624.     d->last_bits= 0;
  1625.  
  1626.     d->mb_skiped= s->mb_skiped;
  1627. }
  1628.  
  1629. static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
  1630.     int i;
  1631.  
  1632.     memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
  1633.     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
  1634.     
  1635.     /* mpeg1 */
  1636.     d->mb_incr= s->mb_incr;
  1637.     for(i=0; i<3; i++)
  1638.         d->last_dc[i]= s->last_dc[i];
  1639.     
  1640.     /* statistics */
  1641.     d->mv_bits= s->mv_bits;
  1642.     d->i_tex_bits= s->i_tex_bits;
  1643.     d->p_tex_bits= s->p_tex_bits;
  1644.     d->i_count= s->i_count;
  1645.     d->p_count= s->p_count;
  1646.     d->skip_count= s->skip_count;
  1647.     d->misc_bits= s->misc_bits;
  1648.  
  1649.     d->mb_intra= s->mb_intra;
  1650.     d->mb_skiped= s->mb_skiped;
  1651.     d->mv_type= s->mv_type;
  1652.     d->mv_dir= s->mv_dir;
  1653.     d->pb= s->pb;
  1654.     if(s->data_partitioning){
  1655.         d->pb2= s->pb2;
  1656.         d->tex_pb= s->tex_pb;
  1657.     }
  1658.     d->block= s->block;
  1659.     for(i=0; i<6; i++)
  1660.         d->block_last_index[i]= s->block_last_index[i];
  1661. }
  1662.  
  1663. static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
  1664.                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
  1665.                            int *dmin, int *next_block, int motion_x, int motion_y)
  1666. {
  1667.     int bits_count;
  1668.     
  1669.     copy_context_before_encode(s, backup, type);
  1670.  
  1671.     s->block= s->blocks[*next_block];
  1672.     s->pb= pb[*next_block];
  1673.     if(s->data_partitioning){
  1674.         s->pb2   = pb2   [*next_block];
  1675.         s->tex_pb= tex_pb[*next_block];
  1676.     }
  1677.  
  1678.     encode_mb(s, motion_x, motion_y);
  1679.  
  1680.     bits_count= get_bit_count(&s->pb);
  1681.     if(s->data_partitioning){
  1682.         bits_count+= get_bit_count(&s->pb2);
  1683.         bits_count+= get_bit_count(&s->tex_pb);
  1684.     }
  1685.  
  1686.     if(bits_count<*dmin){
  1687.         *dmin= bits_count;
  1688.         *next_block^=1;
  1689.  
  1690.         copy_context_after_encode(best, s, type);
  1691.     }
  1692. }
  1693.  
  1694. static void encode_picture(MpegEncContext *s, int picture_number)
  1695. {
  1696.     int mb_x, mb_y, last_gob, pdif = 0;
  1697.     int i;
  1698.     int bits;
  1699.     MpegEncContext best_s, backup_s;
  1700.     UINT8 bit_buf[2][3000];
  1701.     UINT8 bit_buf2[2][3000];
  1702.     UINT8 bit_buf_tex[2][3000];
  1703.     PutBitContext pb[2], pb2[2], tex_pb[2];
  1704.  
  1705.     for(i=0; i<2; i++){
  1706.         init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
  1707.         init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
  1708.         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
  1709.     }
  1710.  
  1711.     s->picture_number = picture_number;
  1712.  
  1713.     s->block_wrap[0]=
  1714.     s->block_wrap[1]=
  1715.     s->block_wrap[2]=
  1716.     s->block_wrap[3]= s->mb_width*2 + 2;
  1717.     s->block_wrap[4]=
  1718.     s->block_wrap[5]= s->mb_width + 2;
  1719.     
  1720.     /* Reset the average MB variance */
  1721.     s->mb_var_sum = 0;
  1722.     s->mc_mb_var_sum = 0;
  1723.  
  1724.     /* we need to initialize some time vars before we can encode b-frames */
  1725.     if (s->h263_pred && !s->h263_msmpeg4)
  1726.         ff_set_mpeg4_time(s, s->picture_number); 
  1727.  
  1728.     /* Estimate motion for every MB */
  1729.     if(s->pict_type != I_TYPE){
  1730.         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
  1731.             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
  1732.             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
  1733.             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
  1734.             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
  1735.             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
  1736.                 s->mb_x = mb_x;
  1737.                 s->mb_y = mb_y;
  1738.                 s->block_index[0]+=2;
  1739.                 s->block_index[1]+=2;
  1740.                 s->block_index[2]+=2;
  1741.                 s->block_index[3]+=2;
  1742.  
  1743.                 /* compute motion vector & mb_type and store in context */
  1744.                 if(s->pict_type==B_TYPE)
  1745.                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
  1746.                 else
  1747.                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
  1748. //                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
  1749.             }
  1750.         }
  1751.         emms_c();
  1752.     }else /* if(s->pict_type == I_TYPE) */{
  1753.         /* I-Frame */
  1754.         //FIXME do we need to zero them?
  1755.         memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
  1756.         memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
  1757.         memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
  1758.     }
  1759.  
  1760.     if(s->mb_var_sum < s->mc_mb_var_sum && s->pict_type == P_TYPE){ //FIXME subtract MV bits
  1761.         s->pict_type= I_TYPE;
  1762.         memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
  1763.         if(s->max_b_frames==0){
  1764.             s->input_pict_type= I_TYPE;
  1765.             s->input_picture_in_gop_number=0;
  1766.         }
  1767. //printf("Scene change detected, encoding as I Frame\n");
  1768.     }
  1769.     
  1770.     if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
  1771.         s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
  1772.         ff_fix_long_p_mvs(s);
  1773.     if(s->pict_type==B_TYPE){
  1774.         s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
  1775.         s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
  1776.  
  1777.         ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
  1778.         ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
  1779.         ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
  1780.         ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
  1781.     }
  1782.     
  1783. //printf("f_code %d ///\n", s->f_code);
  1784.  
  1785. //    printf("%d %d\n", s->avg_mb_var, s->mc_mb_var);
  1786.  
  1787.     if(s->flags&CODEC_FLAG_PASS2)
  1788.         s->qscale = ff_rate_estimate_qscale_pass2(s);
  1789.     else if (!s->fixed_qscale) 
  1790.         s->qscale = ff_rate_estimate_qscale(s);
  1791.  
  1792.     if (s->out_format == FMT_MJPEG) {
  1793.         /* for mjpeg, we do include qscale in the matrix */
  1794.         s->intra_matrix[0] = default_intra_matrix[0];
  1795.         for(i=1;i<64;i++)
  1796.             s->intra_matrix[i] = CLAMP_TO_8BIT((default_intra_matrix[i] * s->qscale) >> 3);
  1797.         convert_matrix(s->q_intra_matrix, s->q_intra_matrix16, 
  1798.                        s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias);
  1799.     }
  1800.  
  1801.     s->last_bits= get_bit_count(&s->pb);
  1802.     switch(s->out_format) {
  1803.     case FMT_MJPEG:
  1804.         mjpeg_picture_header(s);
  1805.         break;
  1806.     case FMT_H263:
  1807.         if (s->h263_msmpeg4) 
  1808.             msmpeg4_encode_picture_header(s, picture_number);
  1809.         else if (s->h263_pred)
  1810.             mpeg4_encode_picture_header(s, picture_number);
  1811.         else if (s->h263_rv10) 
  1812.             rv10_encode_picture_header(s, picture_number);
  1813.         else
  1814.             h263_encode_picture_header(s, picture_number);
  1815.         break;
  1816.     case FMT_MPEG1:
  1817.         mpeg1_encode_picture_header(s, picture_number);
  1818.         break;
  1819.     }
  1820.     bits= get_bit_count(&s->pb);
  1821.     s->header_bits= bits - s->last_bits;
  1822.     s->last_bits= bits;
  1823.     s->mv_bits=0;
  1824.     s->misc_bits=0;
  1825.     s->i_tex_bits=0;
  1826.     s->p_tex_bits=0;
  1827.     s->i_count=0;
  1828.     s->p_count=0;
  1829.     s->skip_count=0;
  1830.  
  1831.     /* init last dc values */
  1832.     /* note: quant matrix value (8) is implied here */
  1833.     s->last_dc[0] = 128;
  1834.     s->last_dc[1] = 128;
  1835.     s->last_dc[2] = 128;
  1836.     s->mb_incr = 1;
  1837.     s->last_mv[0][0][0] = 0;
  1838.     s->last_mv[0][0][1] = 0;
  1839.  
  1840.     /* Get the GOB height based on picture height */
  1841.     if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
  1842.         if (s->height <= 400)
  1843.             s->gob_index = 1;
  1844.         else if (s->height <= 800)
  1845.             s->gob_index = 2;
  1846.         else
  1847.             s->gob_index = 4;
  1848.     }else if(s->codec_id==CODEC_ID_MPEG4){
  1849.         s->gob_index = 1;
  1850.     }
  1851.  
  1852.     if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
  1853.         ff_mpeg4_init_partitions(s);
  1854.  
  1855.     s->resync_mb_x=0;
  1856.     s->resync_mb_y=0;
  1857.     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
  1858.         /* Put GOB header based on RTP MTU for formats which support it per line (H263*)*/
  1859.         /* TODO: Put all this stuff in a separate generic function */
  1860.         if (s->rtp_mode) {
  1861.             if (!mb_y) {
  1862.                 s->ptr_lastgob = s->pb.buf;
  1863.                 s->ptr_last_mb_line = s->pb.buf;
  1864.             } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {
  1865.                 // MN: we could move the space check from h263 -> here, as its not h263 specific
  1866.                 last_gob = h263_encode_gob_header(s, mb_y);
  1867.                 if (last_gob) {
  1868.                     s->first_slice_line = 1;
  1869.                 }else{
  1870.                     /*MN: we reset it here instead at the end of each line cuz mpeg4 can have 
  1871.                           slice lines starting & ending in the middle*/
  1872.                     s->first_slice_line = 0;
  1873.                 }
  1874.             }
  1875.         }
  1876.  
  1877.         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
  1878.         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
  1879.         
  1880.         s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
  1881.         s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
  1882.         s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
  1883.         s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
  1884.         s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
  1885.         s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
  1886.         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
  1887.             const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
  1888.             const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
  1889. //            int d;
  1890.             int dmin=10000000;
  1891.  
  1892.             s->mb_x = mb_x;
  1893.             s->mb_y = mb_y;
  1894.             s->block_index[0]+=2;
  1895.             s->block_index[1]+=2;
  1896.             s->block_index[2]+=2;
  1897.             s->block_index[3]+=2;
  1898.             s->block_index[4]++;
  1899.             s->block_index[5]++;
  1900.             
  1901.             /* write gob / video packet header for formats which support it at any MB (MPEG4) */
  1902.             if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
  1903.                 int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
  1904.  
  1905.                 //the *2 is there so we stay below the requested size
  1906.                 if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){ 
  1907.                     if(s->codec_id==CODEC_ID_MPEG4){
  1908.                         if(s->data_partitioning && s->pict_type!=B_TYPE){
  1909.                             ff_mpeg4_merge_partitions(s);
  1910.                             ff_mpeg4_init_partitions(s);
  1911.                         }
  1912.                         ff_mpeg4_encode_video_packet_header(s);
  1913.  
  1914.                         if(s->flags&CODEC_FLAG_PASS1){
  1915.                             int bits= get_bit_count(&s->pb);
  1916.                             s->misc_bits+= bits - s->last_bits;
  1917.                             s->last_bits= bits;
  1918.                         }
  1919.                         ff_mpeg4_clean_buffers(s);
  1920.                     }
  1921.                     s->ptr_lastgob = pbBufPtr(&s->pb);
  1922.                     s->first_slice_line=1;
  1923.                     s->resync_mb_x=mb_x;
  1924.                     s->resync_mb_y=mb_y;
  1925.                 }
  1926.  
  1927.                 if(  (s->resync_mb_x   == s->mb_x)
  1928.                    && s->resync_mb_y+1 == s->mb_y){
  1929.                     s->first_slice_line=0; 
  1930.                 }
  1931.             }
  1932.  
  1933.             if(mb_type & (mb_type-1)){ // more than 1 MB type possible
  1934.                 int next_block=0;
  1935.                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
  1936.  
  1937.                 copy_context_before_encode(&backup_s, s, -1);
  1938.                 backup_s.pb= s->pb;
  1939.                 best_s.data_partitioning= s->data_partitioning;
  1940.                 if(s->data_partitioning){
  1941.                     backup_s.pb2= s->pb2;
  1942.                     backup_s.tex_pb= s->tex_pb;
  1943.                 }
  1944.  
  1945.                 if(mb_type&MB_TYPE_INTER){
  1946.                     s->mv_dir = MV_DIR_FORWARD;
  1947.                     s->mv_type = MV_TYPE_16X16;
  1948.                     s->mb_intra= 0;
  1949.                     s->mv[0][0][0] = s->p_mv_table[xy][0];
  1950.                     s->mv[0][0][1] = s->p_mv_table[xy][1];
  1951.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
  1952.                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
  1953.                 }
  1954.                 if(mb_type&MB_TYPE_INTER4V){                 
  1955.                     s->mv_dir = MV_DIR_FORWARD;
  1956.                     s->mv_type = MV_TYPE_8X8;
  1957.                     s->mb_intra= 0;
  1958.                     for(i=0; i<4; i++){
  1959.                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
  1960.                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
  1961.                     }
  1962.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
  1963.                                  &dmin, &next_block, 0, 0);
  1964.                 }
  1965.                 if(mb_type&MB_TYPE_FORWARD){
  1966.                     s->mv_dir = MV_DIR_FORWARD;
  1967.                     s->mv_type = MV_TYPE_16X16;
  1968.                     s->mb_intra= 0;
  1969.                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
  1970.                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
  1971.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
  1972.                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
  1973.                 }
  1974.                 if(mb_type&MB_TYPE_BACKWARD){
  1975.                     s->mv_dir = MV_DIR_BACKWARD;
  1976.                     s->mv_type = MV_TYPE_16X16;
  1977.                     s->mb_intra= 0;
  1978.                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
  1979.                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
  1980.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
  1981.                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
  1982.                 }
  1983.                 if(mb_type&MB_TYPE_BIDIR){
  1984.                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
  1985.                     s->mv_type = MV_TYPE_16X16;
  1986.                     s->mb_intra= 0;
  1987.                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
  1988.                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
  1989.                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
  1990.                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
  1991.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
  1992.                                  &dmin, &next_block, 0, 0);
  1993.                 }
  1994.                 if(mb_type&MB_TYPE_DIRECT){
  1995.                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
  1996.                     s->mv_type = MV_TYPE_16X16; //FIXME
  1997.                     s->mb_intra= 0;
  1998.                     s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
  1999.                     s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
  2000.                     s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
  2001.                     s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
  2002.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
  2003.                                  &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
  2004.                 }
  2005.                 if(mb_type&MB_TYPE_INTRA){
  2006.                     s->mv_dir = MV_DIR_FORWARD;
  2007.                     s->mv_type = MV_TYPE_16X16;
  2008.                     s->mb_intra= 1;
  2009.                     s->mv[0][0][0] = 0;
  2010.                     s->mv[0][0][1] = 0;
  2011.                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
  2012.                                  &dmin, &next_block, 0, 0);
  2013.                     /* force cleaning of ac/dc pred stuff if needed ... */
  2014.                     if(s->h263_pred || s->h263_aic)
  2015.                         s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
  2016.                 }
  2017.                 copy_context_after_encode(s, &best_s, -1);
  2018.                 
  2019.                 pb_bits_count= get_bit_count(&s->pb);
  2020.                 flush_put_bits(&s->pb);
  2021.                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
  2022.                 s->pb= backup_s.pb;
  2023.                 
  2024.                 if(s->data_partitioning){
  2025.                     pb2_bits_count= get_bit_count(&s->pb2);
  2026.                     flush_put_bits(&s->pb2);
  2027.                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
  2028.                     s->pb2= backup_s.pb2;
  2029.                     
  2030.                     tex_pb_bits_count= get_bit_count(&s->tex_pb);
  2031.                     flush_put_bits(&s->tex_pb);
  2032.                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
  2033.                     s->tex_pb= backup_s.tex_pb;
  2034.                 }
  2035.                 s->last_bits= get_bit_count(&s->pb);
  2036.             } else {
  2037.                 int motion_x, motion_y;
  2038.                 s->mv_type=MV_TYPE_16X16;
  2039.                 // only one MB-Type possible
  2040.                 switch(mb_type){
  2041.                 case MB_TYPE_INTRA:
  2042.                     s->mv_dir = MV_DIR_FORWARD;
  2043.                     s->mb_intra= 1;
  2044.                     motion_x= s->mv[0][0][0] = 0;
  2045.                     motion_y= s->mv[0][0][1] = 0;
  2046.                     break;
  2047.                 case MB_TYPE_INTER:
  2048.                     s->mv_dir = MV_DIR_FORWARD;
  2049.                     s->mb_intra= 0;
  2050.                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
  2051.                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
  2052.                     break;
  2053.                 case MB_TYPE_INTER4V:
  2054.                     s->mv_dir = MV_DIR_FORWARD;
  2055.                     s->mv_type = MV_TYPE_8X8;
  2056.                     s->mb_intra= 0;
  2057.                     for(i=0; i<4; i++){
  2058.                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
  2059.                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
  2060.                     }
  2061.                     motion_x= motion_y= 0;
  2062.                     break;
  2063.                 case MB_TYPE_DIRECT:
  2064.                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
  2065.                     s->mb_intra= 0;
  2066.                     motion_x=s->b_direct_mv_table[xy][0];
  2067.                     motion_y=s->b_direct_mv_table[xy][1];
  2068.                     s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
  2069.                     s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
  2070.                     s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
  2071.                     s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
  2072.                     break;
  2073.                 case MB_TYPE_BIDIR:
  2074.                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
  2075.                     s->mb_intra= 0;
  2076.                     motion_x=0;
  2077.                     motion_y=0;
  2078.                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
  2079.                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
  2080.                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
  2081.                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
  2082.                     break;
  2083.                 case MB_TYPE_BACKWARD:
  2084.                     s->mv_dir = MV_DIR_BACKWARD;
  2085.                     s->mb_intra= 0;
  2086.                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
  2087.                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
  2088.                     break;
  2089.                 case MB_TYPE_FORWARD:
  2090.                     s->mv_dir = MV_DIR_FORWARD;
  2091.                     s->mb_intra= 0;
  2092.                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
  2093.                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
  2094. //                    printf(" %d %d ", motion_x, motion_y);
  2095.                     break;
  2096.                 default:
  2097.                     motion_x=motion_y=0; //gcc warning fix
  2098.                     printf("illegal MB type\n");
  2099.                 }
  2100.                 encode_mb(s, motion_x, motion_y);
  2101.             }
  2102.             /* clean the MV table in IPS frames for direct mode in B frames */
  2103.             if(s->mb_intra /* && I,P,S_TYPE */){
  2104.                 s->p_mv_table[xy][0]=0;
  2105.                 s->p_mv_table[xy][1]=0;
  2106.             }
  2107.  
  2108.             MPV_decode_mb(s, s->block);
  2109. //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
  2110.         }
  2111.  
  2112.  
  2113.         /* Obtain average GOB size for RTP */
  2114.         if (s->rtp_mode) {
  2115.             if (!mb_y)
  2116.                 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
  2117.             else if (!(mb_y % s->gob_index)) {    
  2118.                 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
  2119.                 s->ptr_last_mb_line = pbBufPtr(&s->pb);
  2120.             }
  2121.             //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y, 
  2122.             //                    (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
  2123.             if(s->codec_id!=CODEC_ID_MPEG4) s->first_slice_line = 0; //FIXME clean
  2124.         }
  2125.     }
  2126.     emms_c();
  2127.  
  2128.     if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
  2129.         ff_mpeg4_merge_partitions(s);
  2130.  
  2131.     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
  2132.         msmpeg4_encode_ext_header(s);
  2133.  
  2134.     if(s->codec_id==CODEC_ID_MPEG4) 
  2135.         ff_mpeg4_stuffing(&s->pb);
  2136.  
  2137.     //if (s->gob_number)
  2138.     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
  2139.     
  2140.     /* Send the last GOB if RTP */    
  2141.     if (s->rtp_mode) {
  2142.         flush_put_bits(&s->pb);
  2143.         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
  2144.         /* Call the RTP callback to send the last GOB */
  2145.         if (s->rtp_callback)
  2146.             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
  2147.         s->ptr_lastgob = pbBufPtr(&s->pb);
  2148.         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
  2149.     }
  2150. }
  2151.  
  2152. static int dct_quantize_c(MpegEncContext *s, 
  2153.                         DCTELEM *block, int n,
  2154.                         int qscale, int *overflow)
  2155. {
  2156.     int i, j, level, last_non_zero, q;
  2157.     const int *qmat;
  2158.     int bias;
  2159.     int max=0;
  2160.     unsigned int threshold1, threshold2;
  2161.     
  2162.     av_fdct (block);
  2163.  
  2164.     /* we need this permutation so that we correct the IDCT
  2165.        permutation. will be moved into DCT code */
  2166.     block_permute(block);
  2167.  
  2168.     if (s->mb_intra) {
  2169.         if (!s->h263_aic) {
  2170.             if (n < 4)
  2171.                 q = s->y_dc_scale;
  2172.             else
  2173.                 q = s->c_dc_scale;
  2174.             q = q << 3;
  2175.         } else
  2176.             /* For AIC we skip quant/dequant of INTRADC */
  2177.             q = 1 << 3;
  2178.             
  2179.         /* note: block[0] is assumed to be positive */
  2180.         block[0] = (block[0] + (q >> 1)) / q;
  2181.         i = 1;
  2182.         last_non_zero = 0;
  2183.         qmat = s->q_intra_matrix[qscale];
  2184.         bias= s->intra_quant_bias<<(QMAT_SHIFT - 3 - QUANT_BIAS_SHIFT);
  2185.     } else {
  2186.         i = 0;
  2187.         last_non_zero = -1;
  2188.         qmat = s->q_inter_matrix[qscale];
  2189.         bias= s->inter_quant_bias<<(QMAT_SHIFT - 3 - QUANT_BIAS_SHIFT);
  2190.     }
  2191.     threshold1= (1<<(QMAT_SHIFT - 3)) - bias - 1;
  2192.     threshold2= threshold1<<1;
  2193.  
  2194.     for(;i<64;i++) {
  2195.         j = zigzag_direct[i];
  2196.         level = block[j];
  2197.         level = level * qmat[j];
  2198.  
  2199. //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
  2200. //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
  2201.         if(((unsigned)(level+threshold1))>threshold2){
  2202.             if(level>0){
  2203.                 level= (bias + level)>>(QMAT_SHIFT - 3);
  2204.                 block[j]= level;
  2205.             }else{
  2206.                 level= (bias - level)>>(QMAT_SHIFT - 3);
  2207.                 block[j]= -level;
  2208.             }
  2209.             max |=level;
  2210.             last_non_zero = i;
  2211.         }else{
  2212.             block[j]=0;
  2213.         }
  2214.     }
  2215.     *overflow= s->max_qcoeff < max; //overflow might have happend
  2216.     
  2217.     return last_non_zero;
  2218. }
  2219.  
  2220. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
  2221.                                    DCTELEM *block, int n, int qscale)
  2222. {
  2223.     int i, level, nCoeffs;
  2224.     const UINT16 *quant_matrix;
  2225.  
  2226.     if(s->alternate_scan) nCoeffs= 64;
  2227.     else nCoeffs= s->block_last_index[n]+1;
  2228.     
  2229.     if (s->mb_intra) {
  2230.         if (n < 4) 
  2231.             block[0] = block[0] * s->y_dc_scale;
  2232.         else
  2233.             block[0] = block[0] * s->c_dc_scale;
  2234.         /* XXX: only mpeg1 */
  2235.         quant_matrix = s->intra_matrix;
  2236.         for(i=1;i<nCoeffs;i++) {
  2237.             int j= zigzag_direct[i];
  2238.             level = block[j];
  2239.             if (level) {
  2240.                 if (level < 0) {
  2241.                     level = -level;
  2242.                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2243.                     level = (level - 1) | 1;
  2244.                     level = -level;
  2245.                 } else {
  2246.                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2247.                     level = (level - 1) | 1;
  2248.                 }
  2249. #ifdef PARANOID
  2250.                 if (level < -2048 || level > 2047)
  2251.                     fprintf(stderr, "unquant error %d %d\n", i, level);
  2252. #endif
  2253.                 block[j] = level;
  2254.             }
  2255.         }
  2256.     } else {
  2257.         i = 0;
  2258.         quant_matrix = s->inter_matrix;
  2259.         for(;i<nCoeffs;i++) {
  2260.             int j= zigzag_direct[i];
  2261.             level = block[j];
  2262.             if (level) {
  2263.                 if (level < 0) {
  2264.                     level = -level;
  2265.                     level = (((level << 1) + 1) * qscale *
  2266.                              ((int) (quant_matrix[j]))) >> 4;
  2267.                     level = (level - 1) | 1;
  2268.                     level = -level;
  2269.                 } else {
  2270.                     level = (((level << 1) + 1) * qscale *
  2271.                              ((int) (quant_matrix[j]))) >> 4;
  2272.                     level = (level - 1) | 1;
  2273.                 }
  2274. #ifdef PARANOID
  2275.                 if (level < -2048 || level > 2047)
  2276.                     fprintf(stderr, "unquant error %d %d\n", i, level);
  2277. #endif
  2278.                 block[j] = level;
  2279.             }
  2280.         }
  2281.     }
  2282. }
  2283.  
  2284. static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
  2285.                                    DCTELEM *block, int n, int qscale)
  2286. {
  2287.     int i, level, nCoeffs;
  2288.     const UINT16 *quant_matrix;
  2289.  
  2290.     if(s->alternate_scan) nCoeffs= 64;
  2291.     else nCoeffs= s->block_last_index[n]+1;
  2292.     
  2293.     if (s->mb_intra) {
  2294.         if (n < 4) 
  2295.             block[0] = block[0] * s->y_dc_scale;
  2296.         else
  2297.             block[0] = block[0] * s->c_dc_scale;
  2298.         quant_matrix = s->intra_matrix;
  2299.         for(i=1;i<nCoeffs;i++) {
  2300.             int j= zigzag_direct[i];
  2301.             level = block[j];
  2302.             if (level) {
  2303.                 if (level < 0) {
  2304.                     level = -level;
  2305.                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2306.                     level = -level;
  2307.                 } else {
  2308.                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2309.                 }
  2310. #ifdef PARANOID
  2311.                 if (level < -2048 || level > 2047)
  2312.                     fprintf(stderr, "unquant error %d %d\n", i, level);
  2313. #endif
  2314.                 block[j] = level;
  2315.             }
  2316.         }
  2317.     } else {
  2318.         int sum=-1;
  2319.         i = 0;
  2320.         quant_matrix = s->inter_matrix;
  2321.         for(;i<nCoeffs;i++) {
  2322.             int j= zigzag_direct[i];
  2323.             level = block[j];
  2324.             if (level) {
  2325.                 if (level < 0) {
  2326.                     level = -level;
  2327.                     level = (((level << 1) + 1) * qscale *
  2328.                              ((int) (quant_matrix[j]))) >> 4;
  2329.                     level = -level;
  2330.                 } else {
  2331.                     level = (((level << 1) + 1) * qscale *
  2332.                              ((int) (quant_matrix[j]))) >> 4;
  2333.                 }
  2334. #ifdef PARANOID
  2335.                 if (level < -2048 || level > 2047)
  2336.                     fprintf(stderr, "unquant error %d %d\n", i, level);
  2337. #endif
  2338.                 block[j] = level;
  2339.                 sum+=level;
  2340.             }
  2341.         }
  2342.         block[63]^=sum&1;
  2343.     }
  2344. }
  2345.  
  2346.  
  2347. static void dct_unquantize_h263_c(MpegEncContext *s, 
  2348.                                   DCTELEM *block, int n, int qscale)
  2349. {
  2350.     int i, level, qmul, qadd;
  2351.     int nCoeffs;
  2352.     
  2353.     if (s->mb_intra) {
  2354.         if (!s->h263_aic) {
  2355.             if (n < 4) 
  2356.                 block[0] = block[0] * s->y_dc_scale;
  2357.             else
  2358.                 block[0] = block[0] * s->c_dc_scale;
  2359.         }
  2360.         i = 1;
  2361.         nCoeffs= 64; //does not allways use zigzag table 
  2362.     } else {
  2363.         i = 0;
  2364.         nCoeffs= zigzag_end[ s->block_last_index[n] ];
  2365.     }
  2366.  
  2367.     qmul = s->qscale << 1;
  2368.     if (s->h263_aic && s->mb_intra)
  2369.         qadd = 0;
  2370.     else
  2371.         qadd = (s->qscale - 1) | 1;
  2372.  
  2373.     for(;i<nCoeffs;i++) {
  2374.         level = block[i];
  2375.         if (level) {
  2376.             if (level < 0) {
  2377.                 level = level * qmul - qadd;
  2378.             } else {
  2379.                 level = level * qmul + qadd;
  2380.             }
  2381. #ifdef PARANOID
  2382.                 if (level < -2048 || level > 2047)
  2383.                     fprintf(stderr, "unquant error %d %d\n", i, level);
  2384. #endif
  2385.             block[i] = level;
  2386.         }
  2387.     }
  2388. }
  2389.  
  2390. static void remove_ac(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
  2391. {
  2392.     int dc, dcb, dcr, y, i;
  2393.     for(i=0; i<4; i++){
  2394.         dc= s->dc_val[0][mb_x*2+1 + (i&1) + (mb_y*2+1 + (i>>1))*(s->mb_width*2+2)];
  2395.         for(y=0; y<8; y++){
  2396.             int x;
  2397.             for(x=0; x<8; x++){
  2398.                 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
  2399.             }
  2400.         }
  2401.     }
  2402.     dcb = s->dc_val[1][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
  2403.     dcr= s->dc_val[2][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
  2404.     for(y=0; y<8; y++){
  2405.         int x;
  2406.         for(x=0; x<8; x++){
  2407.             dest_cb[x + y*(s->linesize>>1)]= dcb/8;
  2408.             dest_cr[x + y*(s->linesize>>1)]= dcr/8;
  2409.         }
  2410.     }
  2411. }
  2412.  
  2413. /**
  2414.  * will conceal past errors, and allso drop b frames if needed
  2415.  *
  2416.  */
  2417. void ff_conceal_past_errors(MpegEncContext *s, int unknown_pos)
  2418. {
  2419.     int mb_x= s->mb_x;
  2420.     int mb_y= s->mb_y;
  2421.     int mb_dist=0;
  2422.     int i, intra_count=0, inter_count=0;
  2423.     int intra_conceal= s->msmpeg4_version ? 50 : 50; //FIXME finetune
  2424.     int inter_conceal= s->msmpeg4_version ? 50 : 50;
  2425.     
  2426.     // for last block
  2427.     if(mb_x>=s->mb_width)  mb_x= s->mb_width -1;
  2428.     if(mb_y>=s->mb_height) mb_y= s->mb_height-1;
  2429.  
  2430.     if(s->decoding_error==0 && unknown_pos){
  2431.         if(s->data_partitioning && s->pict_type!=B_TYPE)
  2432.                 s->decoding_error= DECODING_AC_LOST;
  2433.         else
  2434.                 s->decoding_error= DECODING_DESYNC;
  2435.     }
  2436.  
  2437.     if(s->decoding_error==DECODING_DESYNC && s->pict_type!=B_TYPE) s->next_p_frame_damaged=1;
  2438.  
  2439.     for(i=mb_x + mb_y*s->mb_width; i>=0; i--){
  2440.         if(s->mbintra_table[i]) intra_count++;
  2441.         else                    inter_count++;
  2442.     }
  2443.     
  2444.     if(s->decoding_error==DECODING_AC_LOST){
  2445.         intra_conceal*=2;
  2446.         inter_conceal*=2;
  2447.     }else if(s->decoding_error==DECODING_ACDC_LOST){
  2448.         intra_conceal*=2;
  2449.         inter_conceal*=2;
  2450.     }
  2451.  
  2452.     if(unknown_pos && (intra_count<inter_count)){
  2453.         intra_conceal= inter_conceal= s->mb_num; 
  2454. //        printf("%d %d\n",intra_count, inter_count);
  2455.     }
  2456.  
  2457. //    fprintf(stderr, "concealing errors\n");
  2458.  
  2459.     /* for all MBs from the current one back until the last resync marker */
  2460.     for(; mb_y>=0 && mb_y>=s->resync_mb_y; mb_y--){
  2461.         for(; mb_x>=0; mb_x--){
  2462.             uint8_t *dest_y  = s->current_picture[0] + (mb_y * 16*  s->linesize      ) + mb_x * 16;
  2463.             uint8_t *dest_cb = s->current_picture[1] + (mb_y * 8 * (s->linesize >> 1)) + mb_x * 8;
  2464.             uint8_t *dest_cr = s->current_picture[2] + (mb_y * 8 * (s->linesize >> 1)) + mb_x * 8;
  2465.             int mb_x_backup= s->mb_x; //FIXME pass xy to mpeg_motion
  2466.             int mb_y_backup= s->mb_y;
  2467.             s->mb_x=mb_x;
  2468.             s->mb_y=mb_y;
  2469.             if(s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<intra_conceal){
  2470.                 if(s->decoding_error==DECODING_AC_LOST){
  2471.                     remove_ac(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
  2472. //                    printf("remove ac to %d %d\n", mb_x, mb_y);
  2473.                 }else{
  2474.                     mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
  2475.                                 s->last_picture, 0, 0, put_pixels_tab,
  2476.                                 0/*mx*/, 0/*my*/, 16);
  2477.                 }
  2478.             }
  2479.             else if(!s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<inter_conceal){
  2480.                 int mx=0;
  2481.                 int my=0;
  2482.  
  2483.                 if(s->decoding_error!=DECODING_DESYNC){
  2484.                     int xy= mb_x*2+1 + (mb_y*2+1)*(s->mb_width*2+2);
  2485.                     mx= s->motion_val[ xy ][0];
  2486.                     my= s->motion_val[ xy ][1];
  2487.                 }
  2488.  
  2489.                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
  2490.                             s->last_picture, 0, 0, put_pixels_tab,
  2491.                             mx, my, 16);
  2492.             }
  2493.             s->mb_x= mb_x_backup;
  2494.             s->mb_y= mb_y_backup;
  2495.  
  2496.             if(mb_x== s->resync_mb_x && mb_y== s->resync_mb_y) return;
  2497.             if(!s->mbskip_table[mb_x + mb_y*s->mb_width]) mb_dist++;
  2498.         }
  2499.         mb_x=s->mb_width-1;
  2500.     }
  2501. }
  2502.  
  2503. AVCodec mpeg1video_encoder = {
  2504.     "mpeg1video",
  2505.     CODEC_TYPE_VIDEO,
  2506.     CODEC_ID_MPEG1VIDEO,
  2507.     sizeof(MpegEncContext),
  2508.     MPV_encode_init,
  2509.     MPV_encode_picture,
  2510.     MPV_encode_end,
  2511. };
  2512.  
  2513. AVCodec h263_encoder = {
  2514.     "h263",
  2515.     CODEC_TYPE_VIDEO,
  2516.     CODEC_ID_H263,
  2517.     sizeof(MpegEncContext),
  2518.     MPV_encode_init,
  2519.     MPV_encode_picture,
  2520.     MPV_encode_end,
  2521. };
  2522.  
  2523. AVCodec h263p_encoder = {
  2524.     "h263p",
  2525.     CODEC_TYPE_VIDEO,
  2526.     CODEC_ID_H263P,
  2527.     sizeof(MpegEncContext),
  2528.     MPV_encode_init,
  2529.     MPV_encode_picture,
  2530.     MPV_encode_end,
  2531. };
  2532.  
  2533. AVCodec rv10_encoder = {
  2534.     "rv10",
  2535.     CODEC_TYPE_VIDEO,
  2536.     CODEC_ID_RV10,
  2537.     sizeof(MpegEncContext),
  2538.     MPV_encode_init,
  2539.     MPV_encode_picture,
  2540.     MPV_encode_end,
  2541. };
  2542.  
  2543. AVCodec mjpeg_encoder = {
  2544.     "mjpeg",
  2545.     CODEC_TYPE_VIDEO,
  2546.     CODEC_ID_MJPEG,
  2547.     sizeof(MpegEncContext),
  2548.     MPV_encode_init,
  2549.     MPV_encode_picture,
  2550.     MPV_encode_end,
  2551. };
  2552.  
  2553. AVCodec mpeg4_encoder = {
  2554.     "mpeg4",
  2555.     CODEC_TYPE_VIDEO,
  2556.     CODEC_ID_MPEG4,
  2557.     sizeof(MpegEncContext),
  2558.     MPV_encode_init,
  2559.     MPV_encode_picture,
  2560.     MPV_encode_end,
  2561. };
  2562.  
  2563. AVCodec msmpeg4v1_encoder = {
  2564.     "msmpeg4v1",
  2565.     CODEC_TYPE_VIDEO,
  2566.     CODEC_ID_MSMPEG4V1,
  2567.     sizeof(MpegEncContext),
  2568.     MPV_encode_init,
  2569.     MPV_encode_picture,
  2570.     MPV_encode_end,
  2571. };
  2572.  
  2573. AVCodec msmpeg4v2_encoder = {
  2574.     "msmpeg4v2",
  2575.     CODEC_TYPE_VIDEO,
  2576.     CODEC_ID_MSMPEG4V2,
  2577.     sizeof(MpegEncContext),
  2578.     MPV_encode_init,
  2579.     MPV_encode_picture,
  2580.     MPV_encode_end,
  2581. };
  2582.  
  2583. AVCodec msmpeg4v3_encoder = {
  2584.     "msmpeg4",
  2585.     CODEC_TYPE_VIDEO,
  2586.     CODEC_ID_MSMPEG4V3,
  2587.     sizeof(MpegEncContext),
  2588.     MPV_encode_init,
  2589.     MPV_encode_picture,
  2590.     MPV_encode_end,
  2591. };
  2592.  
  2593. AVCodec wmv1_encoder = {
  2594.     "wmv1",
  2595.     CODEC_TYPE_VIDEO,
  2596.     CODEC_ID_WMV1,
  2597.     sizeof(MpegEncContext),
  2598.     MPV_encode_init,
  2599.     MPV_encode_picture,
  2600.     MPV_encode_end,
  2601. };
  2602.  
  2603. AVCodec wmv2_encoder = {
  2604.     "wmv2",
  2605.     CODEC_TYPE_VIDEO,
  2606.     CODEC_ID_WMV2,
  2607.     sizeof(MpegEncContext),
  2608.     MPV_encode_init,
  2609.     MPV_encode_picture,
  2610.     MPV_encode_end,
  2611. };
  2612.