FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/h261enc.c	Lines:	194	206	94.2 %
Date:	2021-01-21 21:11:50	Branches:	89	106	84.0 %


/*
 * H.261 encoder
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 * Copyright (c) 2004 Maarten Daniels
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * H.261 encoder.
 */

#include "libavutil/attributes.h"
#include "libavutil/avassert.h"
#include "avcodec.h"
#include "mpegutils.h"
#include "mpegvideo.h"
#include "h263.h"
#include "h261.h"
#include "mpegvideodata.h"

static uint8_t uni_h261_rl_len [64*64*2*2];
#define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))

int ff_h261_get_picture_format(int width, int height)
{
    // QCIF
    if (width == 176 && height == 144)
        return 0;
    // CIF
    else if (width == 352 && height == 288)
        return 1;
    // ERROR
    else
        return AVERROR(EINVAL);
}

void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
{
    H261Context *h = (H261Context *)s;
    int format, temp_ref;

    align_put_bits(&s->pb);

    /* Update the pointer to last GOB */
    s->ptr_lastgob = put_bits_ptr(&s->pb);

    put_bits(&s->pb, 20, 0x10); /* PSC */

    temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
               (1001LL * s->avctx->time_base.den);   // FIXME maybe this should use a timestamp
    put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */

    put_bits(&s->pb, 1, 0); /* split screen off */
    put_bits(&s->pb, 1, 0); /* camera  off */
    put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */

    format = ff_h261_get_picture_format(s->width, s->height);

    put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */

    put_bits(&s->pb, 1, 1); /* still image mode */
    put_bits(&s->pb, 1, 1); /* reserved */

    put_bits(&s->pb, 1, 0); /* no PEI */
    if (format == 0)
        h->gob_number = -1;
    else
        h->gob_number = 0;
    s->mb_skip_run = 0;
}

/**
 * Encode a group of blocks header.
 */
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
{
    H261Context *h = (H261Context *)s;
    if (ff_h261_get_picture_format(s->width, s->height) == 0) {
        h->gob_number += 2; // QCIF
    } else {
        h->gob_number++;    // CIF
    }
    put_bits(&s->pb, 16, 1);            /* GBSC */
    put_bits(&s->pb, 4, h->gob_number); /* GN */
    put_bits(&s->pb, 5, s->qscale);     /* GQUANT */
    put_bits(&s->pb, 1, 0);             /* no GEI */
    s->mb_skip_run = 0;
    s->last_mv[0][0][0] = 0;
    s->last_mv[0][0][1] = 0;
}

void ff_h261_reorder_mb_index(MpegEncContext *s)
{
    int index = s->mb_x + s->mb_y * s->mb_width;

    if (index % 11 == 0) {
        if (index % 33 == 0)
            h261_encode_gob_header(s, 0);
        s->last_mv[0][0][0] = 0;
        s->last_mv[0][0][1] = 0;
    }

    /* for CIF the GOB's are fragmented in the middle of a scanline
     * that's why we need to adjust the x and y index of the macroblocks */
    if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
        s->mb_x  = index % 11;
        index   /= 11;
        s->mb_y  = index % 3;
        index   /= 3;
        s->mb_x += 11 * (index % 2);
        index   /= 2;
        s->mb_y += 3 * index;

        ff_init_block_index(s);
        ff_update_block_index(s);
    }
}

static void h261_encode_motion(H261Context *h, int val)
{
    MpegEncContext *const s = &h->s;
    int sign, code;
    if (val == 0) {
        code = 0;
        put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
    } else {
        if (val > 15)
            val -= 32;
        if (val < -16)
            val += 32;
        sign = val < 0;
        code = sign ? -val : val;
        put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
        put_bits(&s->pb, 1, sign);
    }
}

static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
{
    int i, cbp;
    cbp = 0;
    for (i = 0; i < 6; i++)
        if (s->block_last_index[i] >= 0)
            cbp |= 1 << (5 - i);
    return cbp;
}

/**
 * Encode an 8x8 block.
 * @param block the 8x8 block
 * @param n block index (0-3 are luma, 4-5 are chroma)
 */
static void h261_encode_block(H261Context *h, int16_t *block, int n)
{
    MpegEncContext *const s = &h->s;
    int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
    RLTable *rl;

    rl = &ff_h261_rl_tcoeff;
    if (s->mb_intra) {
        /* DC coef */
        level = block[0];
        /* 255 cannot be represented, so we clamp */
        if (level > 254) {
            level    = 254;
            block[0] = 254;
        }
        /* 0 cannot be represented also */
        else if (level < 1) {
            level    = 1;
            block[0] = 1;
        }
        if (level == 128)
            put_bits(&s->pb, 8, 0xff);
        else
            put_bits(&s->pb, 8, level);
        i = 1;
    } else if ((block[0] == 1 || block[0] == -1) &&
               (s->block_last_index[n] > -1)) {
        // special case
        put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
        i = 1;
    } else {
        i = 0;
    }

    /* AC coefs */
    last_index    = s->block_last_index[n];
    last_non_zero = i - 1;
    for (; i <= last_index; i++) {
        j     = s->intra_scantable.permutated[i];
        level = block[j];
        if (level) {
            run    = i - last_non_zero - 1;
            sign   = 0;
            slevel = level;
            if (level < 0) {
                sign  = 1;
                level = -level;
            }
            code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
                                run, level);
            if (run == 0 && level < 16)
                code += 1;
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
            if (code == rl->n) {
                put_bits(&s->pb, 6, run);
                av_assert1(slevel != 0);
                av_assert1(level <= 127);
                put_sbits(&s->pb, 8, slevel);
            } else {
                put_bits(&s->pb, 1, sign);
            }
            last_non_zero = i;
        }
    }
    if (last_index > -1)
        put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
}

void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
                       int motion_x, int motion_y)
{
    H261Context *h = (H261Context *)s;
    int mvd, mv_diff_x, mv_diff_y, i, cbp;
    cbp = 63; // avoid warning
    mvd = 0;

    h->mtype = 0;

    if (!s->mb_intra) {
        /* compute cbp */
        cbp = get_cbp(s, block);

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

        if ((cbp | mvd) == 0) {
            /* skip macroblock */
            s->skip_count++;
            s->mb_skip_run++;
            s->last_mv[0][0][0] = 0;
            s->last_mv[0][0][1] = 0;
            s->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->mb_intra) {
        h->mtype++;

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

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

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

    h->mtype = ff_h261_mtype_map[h->mtype];

    if (IS_QUANT(h->mtype)) {
        ff_set_qscale(s, s->qscale + s->dquant);
        put_bits(&s->pb, 5, s->qscale);
    }

    if (IS_16X16(h->mtype)) {
        mv_diff_x       = (motion_x >> 1) - s->last_mv[0][0][0];
        mv_diff_y       = (motion_y >> 1) - s->last_mv[0][0][1];
        s->last_mv[0][0][0] = (motion_x >> 1);
        s->last_mv[0][0][1] = (motion_y >> 1);
        h261_encode_motion(h, mv_diff_x);
        h261_encode_motion(h, mv_diff_y);
    }

    if (HAS_CBP(h->mtype)) {
        av_assert1(cbp > 0);
        put_bits(&s->pb,
                 ff_h261_cbp_tab[cbp - 1][1],
                 ff_h261_cbp_tab[cbp - 1][0]);
    }
    for (i = 0; i < 6; i++)
        /* encode each block */
        h261_encode_block(h, block[i], i);

    if (!IS_16X16(h->mtype)) {
        s->last_mv[0][0][0] = 0;
        s->last_mv[0][0][1] = 0;
    }
}

static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab)
{
    int slevel, run, last;

    av_assert0(MAX_LEVEL >= 64);
    av_assert0(MAX_RUN   >= 63);

    for(slevel=-64; slevel<64; slevel++){
        if(slevel==0) continue;
        for(run=0; run<64; run++){
            for(last=0; last<=1; last++){
                const int index= UNI_ENC_INDEX(last, run, slevel+64);
                int level= slevel < 0 ? -slevel : slevel;
                int len, code;

                len_tab[index]= 100;

                /* ESC0 */
                code= get_rl_index(rl, 0, run, level);
                len=  rl->table_vlc[code][1] + 1;
                if(last)
                    len += 2;

                if(code!=rl->n && len < len_tab[index]){
                    len_tab [index]= len;
                }
                /* ESC */
                len = rl->table_vlc[rl->n][1];
                if(last)
                    len += 2;

                if(len < len_tab[index]){
                    len_tab [index]= len;
                }
            }
        }
    }
}

av_cold void ff_h261_encode_init(MpegEncContext *s)
{
    ff_h261_common_init();

    s->min_qcoeff       = -127;
    s->max_qcoeff       = 127;
    s->y_dc_scale_table =
    s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
    s->ac_esc_length    = 6+6+8;

    init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len);

    s->intra_ac_vlc_length      = s->inter_ac_vlc_length      = uni_h261_rl_len;
    s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
}

static const AVClass h261_class = {
    .class_name = "h261 encoder",
    .item_name  = av_default_item_name,
    .option     = ff_mpv_generic_options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_h261_encoder = {
    .name           = "h261",
    .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_H261,
    .priv_data_size = sizeof(H261Context),
    .init           = ff_mpv_encode_init,
    .encode2        = ff_mpv_encode_picture,
    .close          = ff_mpv_encode_end,
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                     AV_PIX_FMT_NONE },
    .priv_class     = &h261_class,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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 [64642*2];
38			#define UNI_ENC_INDEX(last,run,level) ((last)12864 + (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			return 0;
45			// CIF
46	✓✗✓✗	122706	else if (width == 352 && height == 288)
47		122706	return 1;
48			// ERROR
49			else
50			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	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		300	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			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			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			level = 254;
182			block[0] = 254;
183			}
184			/* 0 cannot be represented also */
185	✗✓	172932	else if (level < 1) {
186			level = 1;
187			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	✓✓✓✓	623820	} 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		132792	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			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			h->mtype++;
286			} else
287		132792	s->qscale -= s->dquant;
288
289		132792	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			ff_set_qscale(s, s->qscale + s->dquant);
297			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		84380	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(const RLTable rl, uint8_t len_tab)
326			{
327			int slevel, run, last;
328
329			av_assert0(MAX_LEVEL >= 64);
330			av_assert0(MAX_RUN >= 63);
331
332	✓✓	774	for(slevel=-64; slevel<64; slevel++){
333	✓✓	768	if(slevel==0) continue;
334	✓✓	49530	for(run=0; run<64; run++){
335	✓✓	146304	for(last=0; last<=1; last++){
336		97536	const int index= UNI_ENC_INDEX(last, run, slevel+64);
337		97536	int level= slevel < 0 ? -slevel : slevel;
338			int len, code;
339
340		97536	len_tab[index]= 100;
341
342			/* ESC0 */
343		97536	code= get_rl_index(rl, 0, run, level);
344		97536	len= rl->table_vlc[code][1] + 1;
345	✓✓	97536	if(last)
346		48768	len += 2;
347
348	✓✓✓✗	97536	if(code!=rl->n && len < len_tab[index]){
349		1512	len_tab [index]= len;
350			}
351			/* ESC */
352		97536	len = rl->table_vlc[rl->n][1];
353	✓✓	97536	if(last)
354		48768	len += 2;
355
356	✓✓	97536	if(len < len_tab[index]){
357		97344	len_tab [index]= len;
358			}
359			}
360			}
361			}
362		6	}
363
364		6	av_cold void ff_h261_encode_init(MpegEncContext *s)
365			{
366		6	ff_h261_common_init();
367
368		6	s->min_qcoeff = -127;
369		6	s->max_qcoeff = 127;
370		6	s->y_dc_scale_table =
371		6	s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
372		6	s->ac_esc_length = 6+6+8;
373
374		6	init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len);
375
376		6	s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
377		6	s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
378		6	}
379
380			static const AVClass h261_class = {
381			.class_name = "h261 encoder",
382			.item_name = av_default_item_name,
383			.option = ff_mpv_generic_options,
384			.version = LIBAVUTIL_VERSION_INT,
385			};
386
387			AVCodec ff_h261_encoder = {
388			.name = "h261",
389			.long_name = NULL_IF_CONFIG_SMALL("H.261"),
390			.type = AVMEDIA_TYPE_VIDEO,
391			.id = AV_CODEC_ID_H261,
392			.priv_data_size = sizeof(H261Context),
393			.init = ff_mpv_encode_init,
394			.encode2 = ff_mpv_encode_picture,
395			.close = ff_mpv_encode_end,
396			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
397			.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
398			AV_PIX_FMT_NONE },
399			.priv_class = &h261_class,
400			};