LCOV - code coverage report
Current view: top level - libavcodec - h261enc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 194 206 94.2 %
Date: 2017-12-14 01:15:32 Functions: 10 10 100.0 %

          Line data    Source code
       1             : /*
       2             :  * H.261 encoder
       3             :  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
       4             :  * Copyright (c) 2004 Maarten Daniels
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * H.261 encoder.
      26             :  */
      27             : 
      28             : #include "libavutil/attributes.h"
      29             : #include "libavutil/avassert.h"
      30             : #include "avcodec.h"
      31             : #include "mpegutils.h"
      32             : #include "mpegvideo.h"
      33             : #include "h263.h"
      34             : #include "h261.h"
      35             : #include "mpegvideodata.h"
      36             : 
      37             : static uint8_t uni_h261_rl_len [64*64*2*2];
      38             : #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
      39             : 
      40      122706 : int ff_h261_get_picture_format(int width, int height)
      41             : {
      42             :     // QCIF
      43      122706 :     if (width == 176 && height == 144)
      44           0 :         return 0;
      45             :     // CIF
      46      122706 :     else if (width == 352 && height == 288)
      47      122706 :         return 1;
      48             :     // ERROR
      49             :     else
      50           0 :         return AVERROR(EINVAL);
      51             : }
      52             : 
      53         300 : void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
      54             : {
      55         300 :     H261Context *h = (H261Context *)s;
      56             :     int format, temp_ref;
      57             : 
      58         300 :     avpriv_align_put_bits(&s->pb);
      59             : 
      60             :     /* Update the pointer to last GOB */
      61         300 :     s->ptr_lastgob = put_bits_ptr(&s->pb);
      62             : 
      63         300 :     put_bits(&s->pb, 20, 0x10); /* PSC */
      64             : 
      65         600 :     temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
      66         300 :                (1001LL * s->avctx->time_base.den);   // FIXME maybe this should use a timestamp
      67         300 :     put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
      68             : 
      69         300 :     put_bits(&s->pb, 1, 0); /* split screen off */
      70         300 :     put_bits(&s->pb, 1, 0); /* camera  off */
      71         300 :     put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
      72             : 
      73         300 :     format = ff_h261_get_picture_format(s->width, s->height);
      74             : 
      75         300 :     put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
      76             : 
      77         300 :     put_bits(&s->pb, 1, 1); /* still image mode */
      78         300 :     put_bits(&s->pb, 1, 1); /* reserved */
      79             : 
      80         300 :     put_bits(&s->pb, 1, 0); /* no PEI */
      81         300 :     if (format == 0)
      82           0 :         h->gob_number = -1;
      83             :     else
      84         300 :         h->gob_number = 0;
      85         300 :     s->mb_skip_run = 0;
      86         300 : }
      87             : 
      88             : /**
      89             :  * Encode a group of blocks header.
      90             :  */
      91        3600 : static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
      92             : {
      93        3600 :     H261Context *h = (H261Context *)s;
      94        3600 :     if (ff_h261_get_picture_format(s->width, s->height) == 0) {
      95           0 :         h->gob_number += 2; // QCIF
      96             :     } else {
      97        3600 :         h->gob_number++;    // CIF
      98             :     }
      99        3600 :     put_bits(&s->pb, 16, 1);            /* GBSC */
     100        3600 :     put_bits(&s->pb, 4, h->gob_number); /* GN */
     101        3600 :     put_bits(&s->pb, 5, s->qscale);     /* GQUANT */
     102        3600 :     put_bits(&s->pb, 1, 0);             /* no GEI */
     103        3600 :     s->mb_skip_run = 0;
     104        3600 :     s->last_mv[0][0][0] = 0;
     105        3600 :     s->last_mv[0][0][1] = 0;
     106        3600 : }
     107             : 
     108      118800 : void ff_h261_reorder_mb_index(MpegEncContext *s)
     109             : {
     110      118800 :     int index = s->mb_x + s->mb_y * s->mb_width;
     111             : 
     112      118800 :     if (index % 11 == 0) {
     113       10800 :         if (index % 33 == 0)
     114        3600 :             h261_encode_gob_header(s, 0);
     115       10800 :         s->last_mv[0][0][0] = 0;
     116       10800 :         s->last_mv[0][0][1] = 0;
     117             :     }
     118             : 
     119             :     /* for CIF the GOB's are fragmented in the middle of a scanline
     120             :      * that's why we need to adjust the x and y index of the macroblocks */
     121      118800 :     if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
     122      118800 :         s->mb_x  = index % 11;
     123      118800 :         index   /= 11;
     124      118800 :         s->mb_y  = index % 3;
     125      118800 :         index   /= 3;
     126      118800 :         s->mb_x += 11 * (index % 2);
     127      118800 :         index   /= 2;
     128      118800 :         s->mb_y += 3 * index;
     129             : 
     130      118800 :         ff_init_block_index(s);
     131      118800 :         ff_update_block_index(s);
     132             :     }
     133      118800 : }
     134             : 
     135      201048 : static void h261_encode_motion(H261Context *h, int val)
     136             : {
     137      201048 :     MpegEncContext *const s = &h->s;
     138             :     int sign, code;
     139      201048 :     if (val == 0) {
     140      113914 :         code = 0;
     141      113914 :         put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
     142             :     } else {
     143       87134 :         if (val > 15)
     144          45 :             val -= 32;
     145       87134 :         if (val < -16)
     146          35 :             val += 32;
     147       87134 :         sign = val < 0;
     148       87134 :         code = sign ? -val : val;
     149       87134 :         put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
     150       87134 :         put_bits(&s->pb, 1, sign);
     151             :     }
     152      201048 : }
     153             : 
     154      104856 : static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
     155             : {
     156             :     int i, cbp;
     157      104856 :     cbp = 0;
     158      733992 :     for (i = 0; i < 6; i++)
     159      629136 :         if (s->block_last_index[i] >= 0)
     160      261040 :             cbp |= 1 << (5 - i);
     161      104856 :     return cbp;
     162             : }
     163             : 
     164             : /**
     165             :  * Encode an 8x8 block.
     166             :  * @param block the 8x8 block
     167             :  * @param n block index (0-3 are luma, 4-5 are chroma)
     168             :  */
     169      796752 : static void h261_encode_block(H261Context *h, int16_t *block, int n)
     170             : {
     171      796752 :     MpegEncContext *const s = &h->s;
     172             :     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
     173             :     RLTable *rl;
     174             : 
     175      796752 :     rl = &ff_h261_rl_tcoeff;
     176      796752 :     if (s->mb_intra) {
     177             :         /* DC coef */
     178      172932 :         level = block[0];
     179             :         /* 255 cannot be represented, so we clamp */
     180      172932 :         if (level > 254) {
     181           0 :             level    = 254;
     182           0 :             block[0] = 254;
     183             :         }
     184             :         /* 0 cannot be represented also */
     185      172932 :         else if (level < 1) {
     186           0 :             level    = 1;
     187           0 :             block[0] = 1;
     188             :         }
     189      172932 :         if (level == 128)
     190        2093 :             put_bits(&s->pb, 8, 0xff);
     191             :         else
     192      170839 :             put_bits(&s->pb, 8, level);
     193      172932 :         i = 1;
     194      745109 :     } else if ((block[0] == 1 || block[0] == -1) &&
     195      121289 :                (s->block_last_index[n] > -1)) {
     196             :         // special case
     197       85981 :         put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
     198       85981 :         i = 1;
     199             :     } else {
     200      537839 :         i = 0;
     201             :     }
     202             : 
     203             :     /* AC coefs */
     204      796752 :     last_index    = s->block_last_index[n];
     205      796752 :     last_non_zero = i - 1;
     206    10146069 :     for (; i <= last_index; i++) {
     207     9349317 :         j     = s->intra_scantable.permutated[i];
     208     9349317 :         level = block[j];
     209     9349317 :         if (level) {
     210     2765550 :             run    = i - last_non_zero - 1;
     211     2765550 :             sign   = 0;
     212     2765550 :             slevel = level;
     213     2765550 :             if (level < 0) {
     214     1382173 :                 sign  = 1;
     215     1382173 :                 level = -level;
     216             :             }
     217     2765550 :             code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
     218             :                                 run, level);
     219     2765550 :             if (run == 0 && level < 16)
     220     1458226 :                 code += 1;
     221     2765550 :             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
     222     2765550 :             if (code == rl->n) {
     223       72326 :                 put_bits(&s->pb, 6, run);
     224             :                 av_assert1(slevel != 0);
     225             :                 av_assert1(level <= 127);
     226       72326 :                 put_sbits(&s->pb, 8, slevel);
     227             :             } else {
     228     2693224 :                 put_bits(&s->pb, 1, sign);
     229             :             }
     230     2765550 :             last_non_zero = i;
     231             :         }
     232             :     }
     233      796752 :     if (last_index > -1)
     234      433972 :         put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
     235      796752 : }
     236             : 
     237      133678 : void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
     238             :                        int motion_x, int motion_y)
     239             : {
     240      133678 :     H261Context *h = (H261Context *)s;
     241             :     int mvd, mv_diff_x, mv_diff_y, i, cbp;
     242      133678 :     cbp = 63; // avoid warning
     243      133678 :     mvd = 0;
     244             : 
     245      133678 :     h->mtype = 0;
     246             : 
     247      133678 :     if (!s->mb_intra) {
     248             :         /* compute cbp */
     249      104856 :         cbp = get_cbp(s, block);
     250             : 
     251             :         /* mvd indicates if this block is motion compensated */
     252      104856 :         mvd = motion_x | motion_y;
     253             : 
     254      104856 :         if ((cbp | mvd) == 0) {
     255             :             /* skip macroblock */
     256         886 :             s->skip_count++;
     257         886 :             s->mb_skip_run++;
     258         886 :             s->last_mv[0][0][0] = 0;
     259         886 :             s->last_mv[0][0][1] = 0;
     260         886 :             s->qscale -= s->dquant;
     261         886 :             return;
     262             :         }
     263             :     }
     264             : 
     265             :     /* MB is not skipped, encode MBA */
     266      265584 :     put_bits(&s->pb,
     267      132792 :              ff_h261_mba_bits[s->mb_skip_run],
     268      132792 :              ff_h261_mba_code[s->mb_skip_run]);
     269      132792 :     s->mb_skip_run = 0;
     270             : 
     271             :     /* calculate MTYPE */
     272      132792 :     if (!s->mb_intra) {
     273      103970 :         h->mtype++;
     274             : 
     275      103970 :         if (mvd || s->loop_filter)
     276      100524 :             h->mtype += 3;
     277      103970 :         if (s->loop_filter)
     278           0 :             h->mtype += 3;
     279      103970 :         if (cbp)
     280       84380 :             h->mtype++;
     281             :         av_assert1(h->mtype > 1);
     282             :     }
     283             : 
     284      132792 :     if (s->dquant && cbp) {
     285           0 :         h->mtype++;
     286             :     } else
     287      132792 :         s->qscale -= s->dquant;
     288             : 
     289      265584 :     put_bits(&s->pb,
     290      132792 :              ff_h261_mtype_bits[h->mtype],
     291      132792 :              ff_h261_mtype_code[h->mtype]);
     292             : 
     293      132792 :     h->mtype = ff_h261_mtype_map[h->mtype];
     294             : 
     295      132792 :     if (IS_QUANT(h->mtype)) {
     296           0 :         ff_set_qscale(s, s->qscale + s->dquant);
     297           0 :         put_bits(&s->pb, 5, s->qscale);
     298             :     }
     299             : 
     300      132792 :     if (IS_16X16(h->mtype)) {
     301      100524 :         mv_diff_x       = (motion_x >> 1) - s->last_mv[0][0][0];
     302      100524 :         mv_diff_y       = (motion_y >> 1) - s->last_mv[0][0][1];
     303      100524 :         s->last_mv[0][0][0] = (motion_x >> 1);
     304      100524 :         s->last_mv[0][0][1] = (motion_y >> 1);
     305      100524 :         h261_encode_motion(h, mv_diff_x);
     306      100524 :         h261_encode_motion(h, mv_diff_y);
     307             :     }
     308             : 
     309      132792 :     if (HAS_CBP(h->mtype)) {
     310             :         av_assert1(cbp > 0);
     311      168760 :         put_bits(&s->pb,
     312       84380 :                  ff_h261_cbp_tab[cbp - 1][1],
     313       84380 :                  ff_h261_cbp_tab[cbp - 1][0]);
     314             :     }
     315      929544 :     for (i = 0; i < 6; i++)
     316             :         /* encode each block */
     317      796752 :         h261_encode_block(h, block[i], i);
     318             : 
     319      132792 :     if (!IS_16X16(h->mtype)) {
     320       32268 :         s->last_mv[0][0][0] = 0;
     321       32268 :         s->last_mv[0][0][1] = 0;
     322             :     }
     323             : }
     324             : 
     325           6 : static av_cold void init_uni_h261_rl_tab(RLTable *rl, uint32_t *bits_tab,
     326             :                                          uint8_t *len_tab)
     327             : {
     328             :     int slevel, run, last;
     329             : 
     330             :     av_assert0(MAX_LEVEL >= 64);
     331             :     av_assert0(MAX_RUN   >= 63);
     332             : 
     333         774 :     for(slevel=-64; slevel<64; slevel++){
     334         768 :         if(slevel==0) continue;
     335       49530 :         for(run=0; run<64; run++){
     336      146304 :             for(last=0; last<=1; last++){
     337       97536 :                 const int index= UNI_ENC_INDEX(last, run, slevel+64);
     338       97536 :                 int level= slevel < 0 ? -slevel : slevel;
     339             :                 int len, code;
     340             : 
     341       97536 :                 len_tab[index]= 100;
     342             : 
     343             :                 /* ESC0 */
     344       97536 :                 code= get_rl_index(rl, 0, run, level);
     345       97536 :                 len=  rl->table_vlc[code][1] + 1;
     346       97536 :                 if(last)
     347       48768 :                     len += 2;
     348             : 
     349       97536 :                 if(code!=rl->n && len < len_tab[index]){
     350        1512 :                     len_tab [index]= len;
     351             :                 }
     352             :                 /* ESC */
     353       97536 :                 len = rl->table_vlc[rl->n][1];
     354       97536 :                 if(last)
     355       48768 :                     len += 2;
     356             : 
     357       97536 :                 if(len < len_tab[index]){
     358       97344 :                     len_tab [index]= len;
     359             :                 }
     360             :             }
     361             :         }
     362             :     }
     363           6 : }
     364             : 
     365           6 : av_cold void ff_h261_encode_init(MpegEncContext *s)
     366             : {
     367           6 :     ff_h261_common_init();
     368             : 
     369           6 :     s->min_qcoeff       = -127;
     370           6 :     s->max_qcoeff       = 127;
     371           6 :     s->y_dc_scale_table =
     372           6 :     s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
     373           6 :     s->ac_esc_length    = 6+6+8;
     374             : 
     375           6 :     init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, NULL, uni_h261_rl_len);
     376             : 
     377           6 :     s->intra_ac_vlc_length      = s->inter_ac_vlc_length      = uni_h261_rl_len;
     378           6 :     s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
     379           6 : }
     380             : 
     381             : static const AVClass h261_class = {
     382             :     .class_name = "h261 encoder",
     383             :     .item_name  = av_default_item_name,
     384             :     .option     = ff_mpv_generic_options,
     385             :     .version    = LIBAVUTIL_VERSION_INT,
     386             : };
     387             : 
     388             : AVCodec ff_h261_encoder = {
     389             :     .name           = "h261",
     390             :     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
     391             :     .type           = AVMEDIA_TYPE_VIDEO,
     392             :     .id             = AV_CODEC_ID_H261,
     393             :     .priv_data_size = sizeof(H261Context),
     394             :     .init           = ff_mpv_encode_init,
     395             :     .encode2        = ff_mpv_encode_picture,
     396             :     .close          = ff_mpv_encode_end,
     397             :     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
     398             :                                                      AV_PIX_FMT_NONE },
     399             :     .priv_class     = &h261_class,
     400             : };

Generated by: LCOV version 1.13