LCOV - code coverage report
Current view: top level - libavcodec - ituh263enc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 380 445 85.4 %
Date: 2017-12-11 04:34:20 Functions: 12 12 100.0 %

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

Generated by: LCOV version 1.13