git.sesse.net Git - ffmpeg/blob - libavcodec/h261enc.c

   1 /*
   2  * H261 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 "mpegvideo.h"
  32 #include "h263.h"
  33 #include "h261.h"
  34
  35 static uint8_t uni_h261_rl_len [64*64*2*2];
  36 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
  37
  38 int ff_h261_get_picture_format(int width, int height)
  39 {
  40     // QCIF
  41     if (width == 176 && height == 144)
  42         return 0;
  43     // CIF
  44     else if (width == 352 && height == 288)
  45         return 1;
  46     // ERROR
  47     else
  48         return -1;
  49 }
  50
  51 void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
  52 {
  53     H261Context *h = (H261Context *)s;
  54     int format, temp_ref;
  55
  56     avpriv_align_put_bits(&s->pb);
  57
  58     /* Update the pointer to last GOB */
  59     s->ptr_lastgob = put_bits_ptr(&s->pb);
  60
  61     put_bits(&s->pb, 20, 0x10); /* PSC */
  62
  63     temp_ref = s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
  64                (1001 * (int64_t)s->avctx->time_base.den);   // FIXME maybe this should use a timestamp
  65     put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
  66
  67     put_bits(&s->pb, 1, 0); /* split screen off */
  68     put_bits(&s->pb, 1, 0); /* camera  off */
  69     put_bits(&s->pb, 1, 0); /* freeze picture release off */
  70
  71     format = ff_h261_get_picture_format(s->width, s->height);
  72
  73     put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
  74
  75     put_bits(&s->pb, 1, 0); /* still image mode */
  76     put_bits(&s->pb, 1, 0); /* reserved */
  77
  78     put_bits(&s->pb, 1, 0); /* no PEI */
  79     if (format == 0)
  80         h->gob_number = -1;
  81     else
  82         h->gob_number = 0;
  83     s->mb_skip_run = 0;
  84 }
  85
  86 /**
  87  * Encode a group of blocks header.
  88  */
  89 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
  90 {
  91     H261Context *h = (H261Context *)s;
  92     if (ff_h261_get_picture_format(s->width, s->height) == 0) {
  93         h->gob_number += 2; // QCIF
  94     } else {
  95         h->gob_number++;    // CIF
  96     }
  97     put_bits(&s->pb, 16, 1);            /* GBSC */
  98     put_bits(&s->pb, 4, h->gob_number); /* GN */
  99     put_bits(&s->pb, 5, s->qscale);     /* GQUANT */
 100     put_bits(&s->pb, 1, 0);             /* no GEI */
 101     s->mb_skip_run = 0;
 102     s->last_mv[0][0][0] = 0;
 103     s->last_mv[0][0][1] = 0;
 104 }
 105
 106 void ff_h261_reorder_mb_index(MpegEncContext *s)
 107 {
 108     int index = s->mb_x + s->mb_y * s->mb_width;
 109
 110     if (index % 11 == 0) {
 111         if (index % 33 == 0)
 112             h261_encode_gob_header(s, 0);
 113         s->last_mv[0][0][0] = 0;
 114         s->last_mv[0][0][1] = 0;
 115     }
 116
 117     /* for CIF the GOB's are fragmented in the middle of a scanline
 118      * that's why we need to adjust the x and y index of the macroblocks */
 119     if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
 120         s->mb_x  = index % 11;
 121         index   /= 11;
 122         s->mb_y  = index % 3;
 123         index   /= 3;
 124         s->mb_x += 11 * (index % 2);
 125         index   /= 2;
 126         s->mb_y += 3 * index;
 127
 128         ff_init_block_index(s);
 129         ff_update_block_index(s);
 130     }
 131 }
 132
 133 static void h261_encode_motion(H261Context *h, int val)
 134 {
 135     MpegEncContext *const s = &h->s;
 136     int sign, code;
 137     if (val == 0) {
 138         code = 0;
 139         put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
 140     } else {
 141         if (val > 15)
 142             val -= 32;
 143         if (val < -16)
 144             val += 32;
 145         sign = val < 0;
 146         code = sign ? -val : val;
 147         put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
 148         put_bits(&s->pb, 1, sign);
 149     }
 150 }
 151
 152 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
 153 {
 154     int i, cbp;
 155     cbp = 0;
 156     for (i = 0; i < 6; i++)
 157         if (s->block_last_index[i] >= 0)
 158             cbp |= 1 << (5 - i);
 159     return cbp;
 160 }
 161
 162 /**
 163  * Encode an 8x8 block.
 164  * @param block the 8x8 block
 165  * @param n block index (0-3 are luma, 4-5 are chroma)
 166  */
 167 static void h261_encode_block(H261Context *h, int16_t *block, int n)
 168 {
 169     MpegEncContext *const s = &h->s;
 170     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
 171     RLTable *rl;
 172
 173     rl = &ff_h261_rl_tcoeff;
 174     if (s->mb_intra) {
 175         /* DC coef */
 176         level = block[0];
 177         /* 255 cannot be represented, so we clamp */
 178         if (level > 254) {
 179             level    = 254;
 180             block[0] = 254;
 181         }
 182         /* 0 cannot be represented also */
 183         else if (level < 1) {
 184             level    = 1;
 185             block[0] = 1;
 186         }
 187         if (level == 128)
 188             put_bits(&s->pb, 8, 0xff);
 189         else
 190             put_bits(&s->pb, 8, level);
 191         i = 1;
 192     } else if ((block[0] == 1 || block[0] == -1) &&
 193                (s->block_last_index[n] > -1)) {
 194         // special case
 195         put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
 196         i = 1;
 197     } else {
 198         i = 0;
 199     }
 200
 201     /* AC coefs */
 202     last_index    = s->block_last_index[n];
 203     last_non_zero = i - 1;
 204     for (; i <= last_index; i++) {
 205         j     = s->intra_scantable.permutated[i];
 206         level = block[j];
 207         if (level) {
 208             run    = i - last_non_zero - 1;
 209             sign   = 0;
 210             slevel = level;
 211             if (level < 0) {
 212                 sign  = 1;
 213                 level = -level;
 214             }
 215             code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
 216                                 run, level);
 217             if (run == 0 && level < 16)
 218                 code += 1;
 219             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 220             if (code == rl->n) {
 221                 put_bits(&s->pb, 6, run);
 222                 av_assert1(slevel != 0);
 223                 av_assert1(level <= 127);
 224                 put_sbits(&s->pb, 8, slevel);
 225             } else {
 226                 put_bits(&s->pb, 1, sign);
 227             }
 228             last_non_zero = i;
 229         }
 230     }
 231     if (last_index > -1)
 232         put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
 233 }
 234
 235 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
 236                        int motion_x, int motion_y)
 237 {
 238     H261Context *h = (H261Context *)s;
 239     int mvd, mv_diff_x, mv_diff_y, i, cbp;
 240     cbp = 63; // avoid warning
 241     mvd = 0;
 242
 243     h->mtype = 0;
 244
 245     if (!s->mb_intra) {
 246         /* compute cbp */
 247         cbp = get_cbp(s, block);
 248
 249         /* mvd indicates if this block is motion compensated */
 250         mvd = motion_x | motion_y;
 251
 252         if ((cbp | mvd | s->dquant) == 0) {
 253             /* skip macroblock */
 254             s->skip_count++;
 255             s->mb_skip_run++;
 256             s->last_mv[0][0][0] = 0;
 257             s->last_mv[0][0][1] = 0;
 258             return;
 259         }
 260     }
 261
 262     /* MB is not skipped, encode MBA */
 263     put_bits(&s->pb,
 264              ff_h261_mba_bits[s->mb_skip_run],
 265              ff_h261_mba_code[s->mb_skip_run]);
 266     s->mb_skip_run = 0;
 267
 268     /* calculate MTYPE */
 269     if (!s->mb_intra) {
 270         h->mtype++;
 271
 272         if (mvd || s->loop_filter)
 273             h->mtype += 3;
 274         if (s->loop_filter)
 275             h->mtype += 3;
 276         if (cbp || s->dquant)
 277             h->mtype++;
 278         av_assert1(h->mtype > 1);
 279     }
 280
 281     if (s->dquant)
 282         h->mtype++;
 283
 284     put_bits(&s->pb,
 285              ff_h261_mtype_bits[h->mtype],
 286              ff_h261_mtype_code[h->mtype]);
 287
 288     h->mtype = ff_h261_mtype_map[h->mtype];
 289
 290     if (IS_QUANT(h->mtype)) {
 291         ff_set_qscale(s, s->qscale + s->dquant);
 292         put_bits(&s->pb, 5, s->qscale);
 293     }
 294
 295     if (IS_16X16(h->mtype)) {
 296         mv_diff_x       = (motion_x >> 1) - s->last_mv[0][0][0];
 297         mv_diff_y       = (motion_y >> 1) - s->last_mv[0][0][1];
 298         s->last_mv[0][0][0] = (motion_x >> 1);
 299         s->last_mv[0][0][1] = (motion_y >> 1);
 300         h261_encode_motion(h, mv_diff_x);
 301         h261_encode_motion(h, mv_diff_y);
 302     }
 303
 304     if (HAS_CBP(h->mtype)) {
 305         av_assert1(cbp > 0);
 306         put_bits(&s->pb,
 307                  ff_h261_cbp_tab[cbp - 1][1],
 308                  ff_h261_cbp_tab[cbp - 1][0]);
 309     }
 310     for (i = 0; i < 6; i++)
 311         /* encode each block */
 312         h261_encode_block(h, block[i], i);
 313
 314     if (!IS_16X16(h->mtype)) {
 315         s->last_mv[0][0][0] = 0;
 316         s->last_mv[0][0][1] = 0;
 317     }
 318 }
 319
 320 static av_cold void init_uni_h261_rl_tab(RLTable *rl, uint32_t *bits_tab,
 321                                          uint8_t *len_tab)
 322 {
 323     int slevel, run, last;
 324
 325     av_assert0(MAX_LEVEL >= 64);
 326     av_assert0(MAX_RUN   >= 63);
 327
 328     for(slevel=-64; slevel<64; slevel++){
 329         if(slevel==0) continue;
 330         for(run=0; run<64; run++){
 331             for(last=0; last<=1; last++){
 332                 const int index= UNI_ENC_INDEX(last, run, slevel+64);
 333                 int level= slevel < 0 ? -slevel : slevel;
 334                 int len, code;
 335
 336                 len_tab[index]= 100;
 337
 338                 /* ESC0 */
 339                 code= get_rl_index(rl, 0, run, level);
 340                 len=  rl->table_vlc[code][1] + 1;
 341                 if(last)
 342                     len += 2;
 343
 344                 if(code!=rl->n && len < len_tab[index]){
 345                     len_tab [index]= len;
 346                 }
 347                 /* ESC */
 348                 len = rl->table_vlc[rl->n][1];
 349                 if(last)
 350                     len += 2;
 351
 352                 if(len < len_tab[index]){
 353                     len_tab [index]= len;
 354                 }
 355             }
 356         }
 357     }
 358 }
 359
 360 av_cold void ff_h261_encode_init(MpegEncContext *s)
 361 {
 362     ff_h261_common_init();
 363
 364     s->min_qcoeff       = -127;
 365     s->max_qcoeff       = 127;
 366     s->y_dc_scale_table =
 367     s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 368     s->ac_esc_length    = 6+6+8;
 369
 370     init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, NULL, uni_h261_rl_len);
 371
 372     s->intra_ac_vlc_length      = s->inter_ac_vlc_length      = uni_h261_rl_len;
 373     s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
 374 }
 375
 376 FF_MPV_GENERIC_CLASS(h261)
 377
 378 AVCodec ff_h261_encoder = {
 379     .name           = "h261",
 380     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
 381     .type           = AVMEDIA_TYPE_VIDEO,
 382     .id             = AV_CODEC_ID_H261,
 383     .priv_data_size = sizeof(H261Context),
 384     .init           = ff_MPV_encode_init,
 385     .encode2        = ff_MPV_encode_picture,
 386     .close          = ff_MPV_encode_end,
 387     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
 388                                                      AV_PIX_FMT_NONE },
 389     .priv_class     = &h261_class,
 390 };