Function h261_encode_mb

libavcodec/h261enc.c:227–314

}

static void h261_encode_mb(MPVEncContext *const s, int16_t block[6][64],
                           int motion_x, int motion_y)
{
    /* The following is only allowed because this encoder
     * does not use slice threading. */
    H261EncContext *const h = (H261EncContext *)s;
    int mvd, mv_diff_x, mv_diff_y, i, cbp;
    cbp = 63; // avoid warning
    mvd = 0;

    s->c.mtype = 0;

    if (!s->c.mb_intra) {
        /* compute cbp */
        cbp = get_cbp(s->c.block_last_index);

        /* mvd indicates if this block is motion compensated */
        mvd = motion_x | motion_y;

        if ((cbp | mvd) == 0) {
            /* skip macroblock */
            s->mb_skip_run++;
            s->c.last_mv[0][0][0] = 0;
            s->c.last_mv[0][0][1] = 0;
            s->c.qscale -= s->dquant;
            return;
        }
    }

    /* MB is not skipped, encode MBA */
    put_bits(&s->pb,
             ff_h261_mba_bits[s->mb_skip_run],
             ff_h261_mba_code[s->mb_skip_run]);
    s->mb_skip_run = 0;

    /* calculate MTYPE */
    if (!s->c.mb_intra) {
        s->c.mtype++;

        if (mvd || s->loop_filter)
            s->c.mtype += 3;
        if (s->loop_filter)
            s->c.mtype += 3;
        if (cbp)
            s->c.mtype++;
        av_assert1(s->c.mtype > 1);
    }

    if (s->dquant && cbp) {
        s->c.mtype++;
    } else
        s->c.qscale -= s->dquant;

    put_bits(&s->pb,
             ff_h261_mtype_bits[s->c.mtype],
             ff_h261_mtype_code[s->c.mtype]);

    s->c.mtype = ff_h261_mtype_map[s->c.mtype];