Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * ITU H263 bitstream encoder
  3.  * Copyright (c) 2000,2001 Fabrice Bellard
  4.  * H263+ support.
  5.  * Copyright (c) 2001 Juan J. Sierralta P
  6.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
  7.  *
  8.  * This file is part of FFmpeg.
  9.  *
  10.  * FFmpeg is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU Lesser General Public
  12.  * License as published by the Free Software Foundation; either
  13.  * version 2.1 of the License, or (at your option) any later version.
  14.  *
  15.  * FFmpeg is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18.  * Lesser General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU Lesser General Public
  21.  * License along with FFmpeg; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23.  */
  24.  
  25. /**
  26.  * @file
  27.  * h263 bitstream encoder.
  28.  */
  29.  
  30. #include <limits.h>
  31.  
  32. #include "libavutil/attributes.h"
  33. #include "avcodec.h"
  34. #include "mpegvideo.h"
  35. #include "h263.h"
  36. #include "mathops.h"
  37. #include "unary.h"
  38. #include "flv.h"
  39. #include "mpeg4video.h"
  40. #include "internal.h"
  41.  
  42. /**
  43.  * Table of number of bits a motion vector component needs.
  44.  */
  45. static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  46.  
  47. /**
  48.  * Minimal fcode that a motion vector component would need.
  49.  */
  50. static uint8_t fcode_tab[MAX_MV*2+1];
  51.  
  52. /**
  53.  * Minimal fcode that a motion vector component would need in umv.
  54.  * All entries in this table are 1.
  55.  */
  56. static uint8_t umv_fcode_tab[MAX_MV*2+1];
  57.  
  58. //unified encoding tables for run length encoding of coefficients
  59. //unified in the sense that the specification specifies the encoding in several steps.
  60. static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
  61. static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
  62. //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
  63. //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
  64. #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
  65.  
  66. static const uint8_t wrong_run[102] = {
  67.  1,  2,  3,  5,  4, 10,  9,  8,
  68. 11, 15, 17, 16, 23, 22, 21, 20,
  69. 19, 18, 25, 24, 27, 26, 11,  7,
  70.  6,  1,  2, 13,  2,  2,  2,  2,
  71.  6, 12,  3,  9,  1,  3,  4,  3,
  72.  7,  4,  1,  1,  5,  5, 14,  6,
  73.  1,  7,  1,  8,  1,  1,  1,  1,
  74. 10,  1,  1,  5,  9, 17, 25, 24,
  75. 29, 33, 32, 41,  2, 23, 28, 31,
  76.  3, 22, 30,  4, 27, 40,  8, 26,
  77.  6, 39,  7, 38, 16, 37, 15, 10,
  78. 11, 12, 13, 14,  1, 21, 20, 18,
  79. 19,  2,  1, 34, 35, 36
  80. };
  81.  
  82. /**
  83.  * Return the 4 bit value that specifies the given aspect ratio.
  84.  * This may be one of the standard aspect ratios or it specifies
  85.  * that the aspect will be stored explicitly later.
  86.  */
  87. av_const int ff_h263_aspect_to_info(AVRational aspect){
  88.     int i;
  89.  
  90.     if(aspect.num==0) aspect= (AVRational){1,1};
  91.  
  92.     for(i=1; i<6; i++){
  93.         if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
  94.             return i;
  95.         }
  96.     }
  97.  
  98.     return FF_ASPECT_EXTENDED;
  99. }
  100.  
  101. void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
  102. {
  103.     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
  104.     int best_clock_code=1;
  105.     int best_divisor=60;
  106.     int best_error= INT_MAX;
  107.  
  108.     if(s->h263_plus){
  109.         for(i=0; i<2; i++){
  110.             int div, error;
  111.             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
  112.             div= av_clip(div, 1, 127);
  113.             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
  114.             if(error < best_error){
  115.                 best_error= error;
  116.                 best_divisor= div;
  117.                 best_clock_code= i;
  118.             }
  119.         }
  120.     }
  121.     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
  122.     coded_frame_rate= 1800000;
  123.     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
  124.  
  125.     avpriv_align_put_bits(&s->pb);
  126.  
  127.     /* Update the pointer to last GOB */
  128.     s->ptr_lastgob = put_bits_ptr(&s->pb);
  129.     put_bits(&s->pb, 22, 0x20); /* PSC */
  130.     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
  131.                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
  132.     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
  133.  
  134.     put_bits(&s->pb, 1, 1);     /* marker */
  135.     put_bits(&s->pb, 1, 0);     /* h263 id */
  136.     put_bits(&s->pb, 1, 0);     /* split screen off */
  137.     put_bits(&s->pb, 1, 0);     /* camera  off */
  138.     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
  139.  
  140.     format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);
  141.     if (!s->h263_plus) {
  142.         /* H.263v1 */
  143.         put_bits(&s->pb, 3, format);
  144.         put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
  145.         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
  146.         of H.263v1 UMV implies to check the predicted MV after
  147.         calculation of the current MB to see if we're on the limits */
  148.         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
  149.         put_bits(&s->pb, 1, 0);         /* SAC: off */
  150.         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
  151.         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
  152.         put_bits(&s->pb, 5, s->qscale);
  153.         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
  154.     } else {
  155.         int ufep=1;
  156.         /* H.263v2 */
  157.         /* H.263 Plus PTYPE */
  158.  
  159.         put_bits(&s->pb, 3, 7);
  160.         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
  161.         if (format == 8)
  162.             put_bits(&s->pb,3,6); /* Custom Source Format */
  163.         else
  164.             put_bits(&s->pb, 3, format);
  165.  
  166.         put_bits(&s->pb,1, s->custom_pcf);
  167.         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
  168.         put_bits(&s->pb,1,0); /* SAC: off */
  169.         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
  170.         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
  171.         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
  172.         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
  173.         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
  174.         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
  175.         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
  176.         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
  177.         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
  178.         put_bits(&s->pb,3,0); /* Reserved */
  179.  
  180.         put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
  181.  
  182.         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
  183.         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
  184.         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
  185.         put_bits(&s->pb,2,0); /* Reserved */
  186.         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
  187.  
  188.         /* This should be here if PLUSPTYPE */
  189.         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
  190.  
  191.         if (format == 8) {
  192.             /* Custom Picture Format (CPFMT) */
  193.             s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
  194.  
  195.             put_bits(&s->pb,4,s->aspect_ratio_info);
  196.             put_bits(&s->pb,9,(s->width >> 2) - 1);
  197.             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
  198.             put_bits(&s->pb,9,(s->height >> 2));
  199.             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
  200.                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
  201.                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
  202.             }
  203.         }
  204.         if(s->custom_pcf){
  205.             if(ufep){
  206.                 put_bits(&s->pb, 1, best_clock_code);
  207.                 put_bits(&s->pb, 7, best_divisor);
  208.             }
  209.             put_sbits(&s->pb, 2, temp_ref>>8);
  210.         }
  211.  
  212.         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
  213.         if (s->umvplus)
  214. //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
  215. //FIXME check actual requested range
  216.             put_bits(&s->pb,2,1); /* unlimited */
  217.         if(s->h263_slice_structured)
  218.             put_bits(&s->pb,2,0); /* no weird submodes */
  219.  
  220.         put_bits(&s->pb, 5, s->qscale);
  221.     }
  222.  
  223.     put_bits(&s->pb, 1, 0);     /* no PEI */
  224.  
  225.     if(s->h263_slice_structured){
  226.         put_bits(&s->pb, 1, 1);
  227.  
  228.         av_assert1(s->mb_x == 0 && s->mb_y == 0);
  229.         ff_h263_encode_mba(s);
  230.  
  231.         put_bits(&s->pb, 1, 1);
  232.     }
  233.  
  234.     if(s->h263_aic){
  235.          s->y_dc_scale_table=
  236.          s->c_dc_scale_table= ff_aic_dc_scale_table;
  237.     }else{
  238.         s->y_dc_scale_table=
  239.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  240.     }
  241. }
  242.  
  243. /**
  244.  * Encode a group of blocks header.
  245.  */
  246. void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
  247. {
  248.     put_bits(&s->pb, 17, 1); /* GBSC */
  249.  
  250.     if(s->h263_slice_structured){
  251.         put_bits(&s->pb, 1, 1);
  252.  
  253.         ff_h263_encode_mba(s);
  254.  
  255.         if(s->mb_num > 1583)
  256.             put_bits(&s->pb, 1, 1);
  257.         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
  258.         put_bits(&s->pb, 1, 1);
  259.         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
  260.     }else{
  261.         int gob_number= mb_line / s->gob_index;
  262.  
  263.         put_bits(&s->pb, 5, gob_number); /* GN */
  264.         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
  265.         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
  266.     }
  267. }
  268.  
  269. /**
  270.  * modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
  271.  */
  272. void ff_clean_h263_qscales(MpegEncContext *s){
  273.     int i;
  274.     int8_t * const qscale_table = s->current_picture.qscale_table;
  275.  
  276.     ff_init_qscale_tab(s);
  277.  
  278.     for(i=1; i<s->mb_num; i++){
  279.         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
  280.             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
  281.     }
  282.     for(i=s->mb_num-2; i>=0; i--){
  283.         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
  284.             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
  285.     }
  286.  
  287.     if(s->codec_id != AV_CODEC_ID_H263P){
  288.         for(i=1; i<s->mb_num; i++){
  289.             int mb_xy= s->mb_index2xy[i];
  290.  
  291.             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
  292.                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
  293.             }
  294.         }
  295.     }
  296. }
  297.  
  298. static const int dquant_code[5]= {1,0,9,2,3};
  299.  
  300. /**
  301.  * Encode an 8x8 block.
  302.  * @param block the 8x8 block
  303.  * @param n block index (0-3 are luma, 4-5 are chroma)
  304.  */
  305. static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
  306. {
  307.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
  308.     RLTable *rl;
  309.  
  310.     rl = &ff_h263_rl_inter;
  311.     if (s->mb_intra && !s->h263_aic) {
  312.         /* DC coef */
  313.         level = block[0];
  314.         /* 255 cannot be represented, so we clamp */
  315.         if (level > 254) {
  316.             level = 254;
  317.             block[0] = 254;
  318.         }
  319.         /* 0 cannot be represented also */
  320.         else if (level < 1) {
  321.             level = 1;
  322.             block[0] = 1;
  323.         }
  324.         if (level == 128) //FIXME check rv10
  325.             put_bits(&s->pb, 8, 0xff);
  326.         else
  327.             put_bits(&s->pb, 8, level);
  328.         i = 1;
  329.     } else {
  330.         i = 0;
  331.         if (s->h263_aic && s->mb_intra)
  332.             rl = &ff_rl_intra_aic;
  333.  
  334.         if(s->alt_inter_vlc && !s->mb_intra){
  335.             int aic_vlc_bits=0;
  336.             int inter_vlc_bits=0;
  337.             int wrong_pos=-1;
  338.             int aic_code;
  339.  
  340.             last_index = s->block_last_index[n];
  341.             last_non_zero = i - 1;
  342.             for (; i <= last_index; i++) {
  343.                 j = s->intra_scantable.permutated[i];
  344.                 level = block[j];
  345.                 if (level) {
  346.                     run = i - last_non_zero - 1;
  347.                     last = (i == last_index);
  348.  
  349.                     if(level<0) level= -level;
  350.  
  351.                     code = get_rl_index(rl, last, run, level);
  352.                     aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
  353.                     inter_vlc_bits += rl->table_vlc[code][1]+1;
  354.                     aic_vlc_bits   += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
  355.  
  356.                     if (code == rl->n) {
  357.                         inter_vlc_bits += 1+6+8-1;
  358.                     }
  359.                     if (aic_code == ff_rl_intra_aic.n) {
  360.                         aic_vlc_bits += 1+6+8-1;
  361.                         wrong_pos += run + 1;
  362.                     }else
  363.                         wrong_pos += wrong_run[aic_code];
  364.                     last_non_zero = i;
  365.                 }
  366.             }
  367.             i = 0;
  368.             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
  369.                 rl = &ff_rl_intra_aic;
  370.         }
  371.     }
  372.  
  373.     /* AC coefs */
  374.     last_index = s->block_last_index[n];
  375.     last_non_zero = i - 1;
  376.     for (; i <= last_index; i++) {
  377.         j = s->intra_scantable.permutated[i];
  378.         level = block[j];
  379.         if (level) {
  380.             run = i - last_non_zero - 1;
  381.             last = (i == last_index);
  382.             sign = 0;
  383.             slevel = level;
  384.             if (level < 0) {
  385.                 sign = 1;
  386.                 level = -level;
  387.             }
  388.             code = get_rl_index(rl, last, run, level);
  389.             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
  390.             if (code == rl->n) {
  391.               if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
  392.                 put_bits(&s->pb, 1, last);
  393.                 put_bits(&s->pb, 6, run);
  394.  
  395.                 av_assert2(slevel != 0);
  396.  
  397.                 if(level < 128)
  398.                     put_sbits(&s->pb, 8, slevel);
  399.                 else{
  400.                     put_bits(&s->pb, 8, 128);
  401.                     put_sbits(&s->pb, 5, slevel);
  402.                     put_sbits(&s->pb, 6, slevel>>5);
  403.                 }
  404.               }else{
  405.                     ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
  406.               }
  407.             } else {
  408.                 put_bits(&s->pb, 1, sign);
  409.             }
  410.             last_non_zero = i;
  411.         }
  412.     }
  413. }
  414.  
  415. /* Encode MV differences on H.263+ with Unrestricted MV mode */
  416. static void h263p_encode_umotion(MpegEncContext * s, int val)
  417. {
  418.     short sval = 0;
  419.     short i = 0;
  420.     short n_bits = 0;
  421.     short temp_val;
  422.     int code = 0;
  423.     int tcode;
  424.  
  425.     if ( val == 0)
  426.         put_bits(&s->pb, 1, 1);
  427.     else if (val == 1)
  428.         put_bits(&s->pb, 3, 0);
  429.     else if (val == -1)
  430.         put_bits(&s->pb, 3, 2);
  431.     else {
  432.  
  433.         sval = ((val < 0) ? (short)(-val):(short)val);
  434.         temp_val = sval;
  435.  
  436.         while (temp_val != 0) {
  437.             temp_val = temp_val >> 1;
  438.             n_bits++;
  439.         }
  440.  
  441.         i = n_bits - 1;
  442.         while (i > 0) {
  443.             tcode = (sval & (1 << (i-1))) >> (i-1);
  444.             tcode = (tcode << 1) | 1;
  445.             code = (code << 2) | tcode;
  446.             i--;
  447.         }
  448.         code = ((code << 1) | (val < 0)) << 1;
  449.         put_bits(&s->pb, (2*n_bits)+1, code);
  450.     }
  451. }
  452.  
  453. void ff_h263_encode_mb(MpegEncContext * s,
  454.                        int16_t block[6][64],
  455.                        int motion_x, int motion_y)
  456. {
  457.     int cbpc, cbpy, i, cbp, pred_x, pred_y;
  458.     int16_t pred_dc;
  459.     int16_t rec_intradc[6];
  460.     int16_t *dc_ptr[6];
  461.     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
  462.  
  463.     if (!s->mb_intra) {
  464.         /* compute cbp */
  465.         cbp= get_p_cbp(s, block, motion_x, motion_y);
  466.  
  467.         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
  468.             /* skip macroblock */
  469.             put_bits(&s->pb, 1, 1);
  470.             if(interleaved_stats){
  471.                 s->misc_bits++;
  472.                 s->last_bits++;
  473.             }
  474.             s->skip_count++;
  475.  
  476.             return;
  477.         }
  478.         put_bits(&s->pb, 1, 0);         /* mb coded */
  479.  
  480.         cbpc = cbp & 3;
  481.         cbpy = cbp >> 2;
  482.         if(s->alt_inter_vlc==0 || cbpc!=3)
  483.             cbpy ^= 0xF;
  484.         if(s->dquant) cbpc+= 8;
  485.         if(s->mv_type==MV_TYPE_16X16){
  486.             put_bits(&s->pb,
  487.                     ff_h263_inter_MCBPC_bits[cbpc],
  488.                     ff_h263_inter_MCBPC_code[cbpc]);
  489.  
  490.             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
  491.             if(s->dquant)
  492.                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
  493.  
  494.             if(interleaved_stats){
  495.                 s->misc_bits+= get_bits_diff(s);
  496.             }
  497.  
  498.             /* motion vectors: 16x16 mode */
  499.             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
  500.  
  501.             if (!s->umvplus) {
  502.                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
  503.                                                 motion_y - pred_y, 1);
  504.             }
  505.             else {
  506.                 h263p_encode_umotion(s, motion_x - pred_x);
  507.                 h263p_encode_umotion(s, motion_y - pred_y);
  508.                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
  509.                     /* To prevent Start Code emulation */
  510.                     put_bits(&s->pb,1,1);
  511.             }
  512.         }else{
  513.             put_bits(&s->pb,
  514.                     ff_h263_inter_MCBPC_bits[cbpc+16],
  515.                     ff_h263_inter_MCBPC_code[cbpc+16]);
  516.             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
  517.             if(s->dquant)
  518.                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
  519.  
  520.             if(interleaved_stats){
  521.                 s->misc_bits+= get_bits_diff(s);
  522.             }
  523.  
  524.             for(i=0; i<4; i++){
  525.                 /* motion vectors: 8x8 mode*/
  526.                 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
  527.  
  528.                 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
  529.                 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
  530.                 if (!s->umvplus) {
  531.                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
  532.                                                     motion_y - pred_y, 1);
  533.                 }
  534.                 else {
  535.                     h263p_encode_umotion(s, motion_x - pred_x);
  536.                     h263p_encode_umotion(s, motion_y - pred_y);
  537.                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
  538.                         /* To prevent Start Code emulation */
  539.                         put_bits(&s->pb,1,1);
  540.                 }
  541.             }
  542.         }
  543.  
  544.         if(interleaved_stats){
  545.             s->mv_bits+= get_bits_diff(s);
  546.         }
  547.     } else {
  548.         av_assert2(s->mb_intra);
  549.  
  550.         cbp = 0;
  551.         if (s->h263_aic) {
  552.             /* Predict DC */
  553.             for(i=0; i<6; i++) {
  554.                 int16_t level = block[i][0];
  555.                 int scale;
  556.  
  557.                 if(i<4) scale= s->y_dc_scale;
  558.                 else    scale= s->c_dc_scale;
  559.  
  560.                 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
  561.                 level -= pred_dc;
  562.                 /* Quant */
  563.                 if (level >= 0)
  564.                     level = (level + (scale>>1))/scale;
  565.                 else
  566.                     level = (level - (scale>>1))/scale;
  567.  
  568.                 /* AIC can change CBP */
  569.                 if (level == 0 && s->block_last_index[i] == 0)
  570.                     s->block_last_index[i] = -1;
  571.  
  572.                 if(!s->modified_quant){
  573.                     if (level < -127)
  574.                         level = -127;
  575.                     else if (level > 127)
  576.                         level = 127;
  577.                 }
  578.  
  579.                 block[i][0] = level;
  580.                 /* Reconstruction */
  581.                 rec_intradc[i] = scale*level + pred_dc;
  582.                 /* Oddify */
  583.                 rec_intradc[i] |= 1;
  584.                 //if ((rec_intradc[i] % 2) == 0)
  585.                 //    rec_intradc[i]++;
  586.                 /* Clipping */
  587.                 if (rec_intradc[i] < 0)
  588.                     rec_intradc[i] = 0;
  589.                 else if (rec_intradc[i] > 2047)
  590.                     rec_intradc[i] = 2047;
  591.  
  592.                 /* Update AC/DC tables */
  593.                 *dc_ptr[i] = rec_intradc[i];
  594.                 if (s->block_last_index[i] >= 0)
  595.                     cbp |= 1 << (5 - i);
  596.             }
  597.         }else{
  598.             for(i=0; i<6; i++) {
  599.                 /* compute cbp */
  600.                 if (s->block_last_index[i] >= 1)
  601.                     cbp |= 1 << (5 - i);
  602.             }
  603.         }
  604.  
  605.         cbpc = cbp & 3;
  606.         if (s->pict_type == AV_PICTURE_TYPE_I) {
  607.             if(s->dquant) cbpc+=4;
  608.             put_bits(&s->pb,
  609.                 ff_h263_intra_MCBPC_bits[cbpc],
  610.                 ff_h263_intra_MCBPC_code[cbpc]);
  611.         } else {
  612.             if(s->dquant) cbpc+=8;
  613.             put_bits(&s->pb, 1, 0);     /* mb coded */
  614.             put_bits(&s->pb,
  615.                 ff_h263_inter_MCBPC_bits[cbpc + 4],
  616.                 ff_h263_inter_MCBPC_code[cbpc + 4]);
  617.         }
  618.         if (s->h263_aic) {
  619.             /* XXX: currently, we do not try to use ac prediction */
  620.             put_bits(&s->pb, 1, 0);     /* no AC prediction */
  621.         }
  622.         cbpy = cbp >> 2;
  623.         put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
  624.         if(s->dquant)
  625.             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
  626.  
  627.         if(interleaved_stats){
  628.             s->misc_bits+= get_bits_diff(s);
  629.         }
  630.     }
  631.  
  632.     for(i=0; i<6; i++) {
  633.         /* encode each block */
  634.         h263_encode_block(s, block[i], i);
  635.  
  636.         /* Update INTRADC for decoding */
  637.         if (s->h263_aic && s->mb_intra) {
  638.             block[i][0] = rec_intradc[i];
  639.  
  640.         }
  641.     }
  642.  
  643.     if(interleaved_stats){
  644.         if (!s->mb_intra) {
  645.             s->p_tex_bits+= get_bits_diff(s);
  646.             s->f_count++;
  647.         }else{
  648.             s->i_tex_bits+= get_bits_diff(s);
  649.             s->i_count++;
  650.         }
  651.     }
  652. }
  653.  
  654. void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
  655. {
  656.     int range, bit_size, sign, code, bits;
  657.  
  658.     if (val == 0) {
  659.         /* zero vector */
  660.         code = 0;
  661.         put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
  662.     } else {
  663.         bit_size = f_code - 1;
  664.         range = 1 << bit_size;
  665.         /* modulo encoding */
  666.         val = sign_extend(val, 6 + bit_size);
  667.         sign = val>>31;
  668.         val= (val^sign)-sign;
  669.         sign&=1;
  670.  
  671.         val--;
  672.         code = (val >> bit_size) + 1;
  673.         bits = val & (range - 1);
  674.  
  675.         put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
  676.         if (bit_size > 0) {
  677.             put_bits(&s->pb, bit_size, bits);
  678.         }
  679.     }
  680. }
  681.  
  682. static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
  683. {
  684.     int f_code;
  685.     int mv;
  686.  
  687.     for(f_code=1; f_code<=MAX_FCODE; f_code++){
  688.         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
  689.             int len;
  690.  
  691.             if(mv==0) len= ff_mvtab[0][1];
  692.             else{
  693.                 int val, bit_size, code;
  694.  
  695.                 bit_size = f_code - 1;
  696.  
  697.                 val=mv;
  698.                 if (val < 0)
  699.                     val = -val;
  700.                 val--;
  701.                 code = (val >> bit_size) + 1;
  702.                 if(code<33){
  703.                     len= ff_mvtab[code][1] + 1 + bit_size;
  704.                 }else{
  705.                     len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
  706.                 }
  707.             }
  708.  
  709.             mv_penalty[f_code][mv+MAX_MV]= len;
  710.         }
  711.     }
  712.  
  713.     for(f_code=MAX_FCODE; f_code>0; f_code--){
  714.         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
  715.             fcode_tab[mv+MAX_MV]= f_code;
  716.         }
  717.     }
  718.  
  719.     for(mv=0; mv<MAX_MV*2+1; mv++){
  720.         umv_fcode_tab[mv]= 1;
  721.     }
  722. }
  723.  
  724. static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
  725.                                          uint8_t *len_tab)
  726. {
  727.     int slevel, run, last;
  728.  
  729.     av_assert0(MAX_LEVEL >= 64);
  730.     av_assert0(MAX_RUN   >= 63);
  731.  
  732.     for(slevel=-64; slevel<64; slevel++){
  733.         if(slevel==0) continue;
  734.         for(run=0; run<64; run++){
  735.             for(last=0; last<=1; last++){
  736.                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
  737.                 int level= slevel < 0 ? -slevel : slevel;
  738.                 int sign= slevel < 0 ? 1 : 0;
  739.                 int bits, len, code;
  740.  
  741.                 len_tab[index]= 100;
  742.  
  743.                 /* ESC0 */
  744.                 code= get_rl_index(rl, last, run, level);
  745.                 bits= rl->table_vlc[code][0];
  746.                 len=  rl->table_vlc[code][1];
  747.                 bits=bits*2+sign; len++;
  748.  
  749.                 if(code!=rl->n && len < len_tab[index]){
  750.                     if(bits_tab) bits_tab[index]= bits;
  751.                     len_tab [index]= len;
  752.                 }
  753.                 /* ESC */
  754.                 bits= rl->table_vlc[rl->n][0];
  755.                 len = rl->table_vlc[rl->n][1];
  756.                 bits=bits*2+last; len++;
  757.                 bits=bits*64+run; len+=6;
  758.                 bits=bits*256+(level&0xff); len+=8;
  759.  
  760.                 if(len < len_tab[index]){
  761.                     if(bits_tab) bits_tab[index]= bits;
  762.                     len_tab [index]= len;
  763.                 }
  764.             }
  765.         }
  766.     }
  767. }
  768.  
  769. av_cold void ff_h263_encode_init(MpegEncContext *s)
  770. {
  771.     static int done = 0;
  772.  
  773.     if (!done) {
  774.         done = 1;
  775.  
  776.         ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
  777.         ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
  778.  
  779.         init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
  780.         init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
  781.  
  782.         init_mv_penalty_and_fcode(s);
  783.     }
  784.     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
  785.  
  786.     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
  787.     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
  788.     if(s->h263_aic){
  789.         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
  790.         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
  791.     }
  792.     s->ac_esc_length= 7+1+6+8;
  793.  
  794.     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
  795.     switch(s->codec_id){
  796.     case AV_CODEC_ID_MPEG4:
  797.         s->fcode_tab= fcode_tab;
  798.         break;
  799.     case AV_CODEC_ID_H263P:
  800.         if(s->umvplus)
  801.             s->fcode_tab= umv_fcode_tab;
  802.         if(s->modified_quant){
  803.             s->min_qcoeff= -2047;
  804.             s->max_qcoeff=  2047;
  805.         }else{
  806.             s->min_qcoeff= -127;
  807.             s->max_qcoeff=  127;
  808.         }
  809.         break;
  810.         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
  811.     case AV_CODEC_ID_FLV1:
  812.         if (s->h263_flv > 1) {
  813.             s->min_qcoeff= -1023;
  814.             s->max_qcoeff=  1023;
  815.         } else {
  816.             s->min_qcoeff= -127;
  817.             s->max_qcoeff=  127;
  818.         }
  819.         s->y_dc_scale_table=
  820.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  821.         break;
  822.     default: //nothing needed - default table already set in mpegvideo.c
  823.         s->min_qcoeff= -127;
  824.         s->max_qcoeff=  127;
  825.         s->y_dc_scale_table=
  826.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  827.     }
  828. }
  829.  
  830. void ff_h263_encode_mba(MpegEncContext *s)
  831. {
  832.     int i, mb_pos;
  833.  
  834.     for(i=0; i<6; i++){
  835.         if(s->mb_num-1 <= ff_mba_max[i]) break;
  836.     }
  837.     mb_pos= s->mb_x + s->mb_width*s->mb_y;
  838.     put_bits(&s->pb, ff_mba_length[i], mb_pos);
  839. }
  840.