FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/h261enc.c	Lines:	197	209	94.3 %
Date:	2021-04-19 06:27:07	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 "libavutil/thread.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;
                }
            }
        }
    }
}

static av_cold void h261_encode_init_static(void)
{
    static uint8_t h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];

    ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store);
    init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len);
}

av_cold void ff_h261_encode_init(MpegEncContext *s)
{
    static AVOnce init_static_once = AV_ONCE_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;

    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;
    ff_thread_once(&init_static_once, h261_encode_init_static);
}

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_THREADSAFE | 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 "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 [64642*2];
39			#define UNI_ENC_INDEX(last,run,level) ((last)12864 + (run)*128 + (level))
40
41		122706	int ff_h261_get_picture_format(int width, int height)
42			{
43			// QCIF
44	✗✓✗✗	122706	if (width == 176 && height == 144)
45			return 0;
46			// CIF
47	✓✗✓✗	122706	else if (width == 352 && height == 288)
48		122706	return 1;
49			// ERROR
50			else
51			return AVERROR(EINVAL);
52			}
53
54		300	void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
55			{
56		300	H261Context h = (H261Context )s;
57			int format, temp_ref;
58
59		300	align_put_bits(&s->pb);
60
61			/* Update the pointer to last GOB */
62		300	s->ptr_lastgob = put_bits_ptr(&s->pb);
63
64		300	put_bits(&s->pb, 20, 0x10); /* PSC */
65
66		300	temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
67		300	(1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp
68		300	put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
69
70		300	put_bits(&s->pb, 1, 0); /* split screen off */
71		300	put_bits(&s->pb, 1, 0); /* camera off */
72		300	put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
73
74		300	format = ff_h261_get_picture_format(s->width, s->height);
75
76		300	put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
77
78		300	put_bits(&s->pb, 1, 1); /* still image mode */
79		300	put_bits(&s->pb, 1, 1); /* reserved */
80
81		300	put_bits(&s->pb, 1, 0); /* no PEI */
82	✗✓	300	if (format == 0)
83			h->gob_number = -1;
84			else
85		300	h->gob_number = 0;
86		300	s->mb_skip_run = 0;
87		300	}
88
89			/**
90			* Encode a group of blocks header.
91			*/
92		3600	static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
93			{
94		3600	H261Context h = (H261Context )s;
95	✗✓	3600	if (ff_h261_get_picture_format(s->width, s->height) == 0) {
96			h->gob_number += 2; // QCIF
97			} else {
98		3600	h->gob_number++; // CIF
99			}
100		3600	put_bits(&s->pb, 16, 1); /* GBSC */
101		3600	put_bits(&s->pb, 4, h->gob_number); /* GN */
102		3600	put_bits(&s->pb, 5, s->qscale); /* GQUANT */
103		3600	put_bits(&s->pb, 1, 0); /* no GEI */
104		3600	s->mb_skip_run = 0;
105		3600	s->last_mv[0][0][0] = 0;
106		3600	s->last_mv[0][0][1] = 0;
107		3600	}
108
109		118800	void ff_h261_reorder_mb_index(MpegEncContext *s)
110			{
111		118800	int index = s->mb_x + s->mb_y * s->mb_width;
112
113	✓✓	118800	if (index % 11 == 0) {
114	✓✓	10800	if (index % 33 == 0)
115		3600	h261_encode_gob_header(s, 0);
116		10800	s->last_mv[0][0][0] = 0;
117		10800	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	✓✗	118800	if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
123		118800	s->mb_x = index % 11;
124		118800	index /= 11;
125		118800	s->mb_y = index % 3;
126		118800	index /= 3;
127		118800	s->mb_x += 11 * (index % 2);
128		118800	index /= 2;
129		118800	s->mb_y += 3 * index;
130
131		118800	ff_init_block_index(s);
132		118800	ff_update_block_index(s);
133			}
134		118800	}
135
136		201048	static void h261_encode_motion(H261Context *h, int val)
137			{
138		201048	MpegEncContext *const s = &h->s;
139			int sign, code;
140	✓✓	201048	if (val == 0) {
141		113914	code = 0;
142		113914	put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
143			} else {
144	✓✓	87134	if (val > 15)
145		45	val -= 32;
146	✓✓	87134	if (val < -16)
147		35	val += 32;
148		87134	sign = val < 0;
149	✓✓	87134	code = sign ? -val : val;
150		87134	put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
151		87134	put_bits(&s->pb, 1, sign);
152			}
153		201048	}
154
155		104856	static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
156			{
157			int i, cbp;
158		104856	cbp = 0;
159	✓✓	733992	for (i = 0; i < 6; i++)
160	✓✓	629136	if (s->block_last_index[i] >= 0)
161		261040	cbp \|= 1 << (5 - i);
162		104856	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		796752	static void h261_encode_block(H261Context h, int16_t block, int n)
171			{
172		796752	MpegEncContext *const s = &h->s;
173			int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
174			RLTable *rl;
175
176		796752	rl = &ff_h261_rl_tcoeff;
177	✓✓	796752	if (s->mb_intra) {
178			/* DC coef */
179		172932	level = block[0];
180			/* 255 cannot be represented, so we clamp */
181	✗✓	172932	if (level > 254) {
182			level = 254;
183			block[0] = 254;
184			}
185			/* 0 cannot be represented also */
186	✗✓	172932	else if (level < 1) {
187			level = 1;
188			block[0] = 1;
189			}
190	✓✓	172932	if (level == 128)
191		2093	put_bits(&s->pb, 8, 0xff);
192			else
193		170839	put_bits(&s->pb, 8, level);
194		172932	i = 1;
195	✓✓✓✓	623820	} else if ((block[0] == 1 \|\| block[0] == -1) &&
196	✓✓	121289	(s->block_last_index[n] > -1)) {
197			// special case
198	✓✓	85981	put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
199		85981	i = 1;
200			} else {
201		537839	i = 0;
202			}
203
204			/* AC coefs */
205		796752	last_index = s->block_last_index[n];
206		796752	last_non_zero = i - 1;
207	✓✓	10146069	for (; i <= last_index; i++) {
208		9349317	j = s->intra_scantable.permutated[i];
209		9349317	level = block[j];
210	✓✓	9349317	if (level) {
211		2765550	run = i - last_non_zero - 1;
212		2765550	sign = 0;
213		2765550	slevel = level;
214	✓✓	2765550	if (level < 0) {
215		1382173	sign = 1;
216		1382173	level = -level;
217			}
218		2765550	code = get_rl_index(rl, 0 /no last in H.261, EOB is used/,
219			run, level);
220	✓✓✓✓	2765550	if (run == 0 && level < 16)
221		1458226	code += 1;
222		2765550	put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
223	✓✓	2765550	if (code == rl->n) {
224		72326	put_bits(&s->pb, 6, run);
225			av_assert1(slevel != 0);
226			av_assert1(level <= 127);
227		72326	put_sbits(&s->pb, 8, slevel);
228			} else {
229		2693224	put_bits(&s->pb, 1, sign);
230			}
231		2765550	last_non_zero = i;
232			}
233			}
234	✓✓	796752	if (last_index > -1)
235		433972	put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
236		796752	}
237
238		133678	void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
239			int motion_x, int motion_y)
240			{
241		133678	H261Context h = (H261Context )s;
242			int mvd, mv_diff_x, mv_diff_y, i, cbp;
243		133678	cbp = 63; // avoid warning
244		133678	mvd = 0;
245
246		133678	h->mtype = 0;
247
248	✓✓	133678	if (!s->mb_intra) {
249			/* compute cbp */
250		104856	cbp = get_cbp(s, block);
251
252			/* mvd indicates if this block is motion compensated */
253		104856	mvd = motion_x \| motion_y;
254
255	✓✓	104856	if ((cbp \| mvd) == 0) {
256			/* skip macroblock */
257		886	s->skip_count++;
258		886	s->mb_skip_run++;
259		886	s->last_mv[0][0][0] = 0;
260		886	s->last_mv[0][0][1] = 0;
261		886	s->qscale -= s->dquant;
262		886	return;
263			}
264			}
265
266			/* MB is not skipped, encode MBA */
267		132792	put_bits(&s->pb,
268		132792	ff_h261_mba_bits[s->mb_skip_run],
269		132792	ff_h261_mba_code[s->mb_skip_run]);
270		132792	s->mb_skip_run = 0;
271
272			/* calculate MTYPE */
273	✓✓	132792	if (!s->mb_intra) {
274		103970	h->mtype++;
275
276	✓✓✗✓	103970	if (mvd \|\| s->loop_filter)
277		100524	h->mtype += 3;
278	✗✓	103970	if (s->loop_filter)
279			h->mtype += 3;
280	✓✓	103970	if (cbp)
281		84380	h->mtype++;
282			av_assert1(h->mtype > 1);
283			}
284
285	✗✓✗✗	132792	if (s->dquant && cbp) {
286			h->mtype++;
287			} else
288		132792	s->qscale -= s->dquant;
289
290		132792	put_bits(&s->pb,
291		132792	ff_h261_mtype_bits[h->mtype],
292		132792	ff_h261_mtype_code[h->mtype]);
293
294		132792	h->mtype = ff_h261_mtype_map[h->mtype];
295
296	✗✓	132792	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	✓✓	132792	if (IS_16X16(h->mtype)) {
302		100524	mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0];
303		100524	mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1];
304		100524	s->last_mv[0][0][0] = (motion_x >> 1);
305		100524	s->last_mv[0][0][1] = (motion_y >> 1);
306		100524	h261_encode_motion(h, mv_diff_x);
307		100524	h261_encode_motion(h, mv_diff_y);
308			}
309
310	✓✓	132792	if (HAS_CBP(h->mtype)) {
311			av_assert1(cbp > 0);
312		84380	put_bits(&s->pb,
313		84380	ff_h261_cbp_tab[cbp - 1][1],
314		84380	ff_h261_cbp_tab[cbp - 1][0]);
315			}
316	✓✓	929544	for (i = 0; i < 6; i++)
317			/* encode each block */
318		796752	h261_encode_block(h, block[i], i);
319
320	✓✓	132792	if (!IS_16X16(h->mtype)) {
321		32268	s->last_mv[0][0][0] = 0;
322		32268	s->last_mv[0][0][1] = 0;
323			}
324			}
325
326		6	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	✓✓	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	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		6	ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store);
370		6	init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len);
371		6	}
372
373		6	av_cold void ff_h261_encode_init(MpegEncContext *s)
374			{
375			static AVOnce init_static_once = AV_ONCE_INIT;
376
377		6	s->min_qcoeff = -127;
378		6	s->max_qcoeff = 127;
379		6	s->y_dc_scale_table =
380		6	s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
381		6	s->ac_esc_length = 6+6+8;
382
383		6	s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
384		6	s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
385		6	ff_thread_once(&init_static_once, h261_encode_init_static);
386		6	}
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			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			};