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

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