FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/h261enc.c
Date: 2026-01-23 19:11:46
Exec Total Coverage
Lines: 182 193 94.3%
Functions: 9 9 100.0%
Branches: 67 80 83.8%
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 "codec_internal.h"
33 #include "mpegutils.h"
34 #include "mpegvideo.h"
35 #include "h261.h"
36 #include "h261enc.h"
37 #include "mpegvideoenc.h"
38 #include "put_bits.h"
39
40 #define H261_MAX_RUN 26
41 #define H261_MAX_LEVEL 15
42 #define H261_ESC_LEN (6 + 6 + 8)
43 #define MV_TAB_OFFSET 32
44
45 static struct VLCLUT {
46 uint8_t len;
47 uint16_t code;
48 } vlc_lut[H261_MAX_RUN + 1][32 /* 0..2 * H261_MAX_LEN are used */];
49
50 // Not const despite never being initialized because doing so would
51 // put it into .rodata instead of .bss and bloat the binary.
52 // mv_penalty exists so that the motion estimation code can avoid branches.
53 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
54 static uint8_t uni_h261_rl_len [64 * 128];
55 static uint8_t uni_h261_rl_len_last[64 * 128];
56 static uint8_t h261_mv_codes[64][2];
57
58 typedef struct H261EncContext {
59 MPVMainEncContext s;
60
61 int gob_number;
62 enum {
63 H261_QCIF = 0,
64 H261_CIF = 1,
65 } format;
66 } H261EncContext;
67
68 300 static int h261_encode_picture_header(MPVMainEncContext *const m)
69 {
70 300 H261EncContext *const h = (H261EncContext *)m;
71 300 MPVEncContext *const s = &h->s.s;
72 int temp_ref;
73
74 300 put_bits_assume_flushed(&s->pb);
75
76 300 put_bits(&s->pb, 20, 0x10); /* PSC */
77
78 300 temp_ref = s->picture_number * 30000LL * s->c.avctx->time_base.num /
79 300 (1001LL * s->c.avctx->time_base.den); // FIXME maybe this should use a timestamp
80 300 put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
81
82 300 put_bits(&s->pb, 1, 0); /* split screen off */
83 300 put_bits(&s->pb, 1, 0); /* camera off */
84 300 put_bits(&s->pb, 1, s->c.pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
85
86 300 put_bits(&s->pb, 1, h->format); /* 0 == QCIF, 1 == CIF */
87
88 300 put_bits(&s->pb, 1, 1); /* still image mode */
89 300 put_bits(&s->pb, 1, 1); /* reserved */
90
91 300 put_bits(&s->pb, 1, 0); /* no PEI */
92 300 h->gob_number = h->format - 1;
93 300 s->mb_skip_run = 0;
94
95 300 return 0;
96 }
97
98 /**
99 * Encode a group of blocks header.
100 */
101 3600 static void h261_encode_gob_header(MPVEncContext *const s, int mb_line)
102 {
103 3600 H261EncContext *const h = (H261EncContext *)s;
104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3600 times.
 3600 if (h->format == H261_QCIF) {
105 ✗ h->gob_number += 2; // QCIF
106 } else {
107 3600 h->gob_number++; // CIF
108 }
109 3600 put_bits(&s->pb, 16, 1); /* GBSC */
110 3600 put_bits(&s->pb, 4, h->gob_number); /* GN */
111 3600 put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
112 3600 put_bits(&s->pb, 1, 0); /* no GEI */
113 3600 s->mb_skip_run = 0;
114 3600 s->c.last_mv[0][0][0] = 0;
115 3600 s->c.last_mv[0][0][1] = 0;
116 3600 }
117
118 118800 void ff_h261_reorder_mb_index(MPVEncContext *const s)
119 {
120 118800 const H261EncContext *const h = (H261EncContext*)s;
121 118800 int index = s->c.mb_x + s->c.mb_y * s->c.mb_width;
122
123
2/2
✓ Branch 0 taken 10800 times.
✓ Branch 1 taken 108000 times.
 118800 if (index % 11 == 0) {
124
2/2
✓ Branch 0 taken 3600 times.
✓ Branch 1 taken 7200 times.
 10800 if (index % 33 == 0)
125 3600 h261_encode_gob_header(s, 0);
126 10800 s->c.last_mv[0][0][0] = 0;
127 10800 s->c.last_mv[0][0][1] = 0;
128 }
129
130 /* for CIF the GOB's are fragmented in the middle of a scanline
131 * that's why we need to adjust the x and y index of the macroblocks */
132
1/2
✓ Branch 0 taken 118800 times.
✗ Branch 1 not taken.
 118800 if (h->format == H261_CIF) {
133 118800 s->c.mb_x = index % 11;
134 118800 index /= 11;
135 118800 s->c.mb_y = index % 3;
136 118800 index /= 3;
137 118800 s->c.mb_x += 11 * (index % 2);
138 118800 index /= 2;
139 118800 s->c.mb_y += 3 * index;
140
141 118800 ff_init_block_index(&s->c);
142 118800 ff_update_block_index(&s->c, 8, 0, 1);
143 }
144 118800 }
145
146 205596 static void h261_encode_motion(PutBitContext *pb, int val)
147 {
148 205596 put_bits(pb, h261_mv_codes[MV_TAB_OFFSET + val][1],
149 205596 h261_mv_codes[MV_TAB_OFFSET + val][0]);
150 205596 }
151
152 105360 static inline int get_cbp(const int block_last_index[6])
153 {
154 int i, cbp;
155 105360 cbp = 0;
156
2/2
✓ Branch 0 taken 632160 times.
✓ Branch 1 taken 105360 times.
 737520 for (i = 0; i < 6; i++)
157
2/2
✓ Branch 0 taken 276433 times.
✓ Branch 1 taken 355727 times.
 632160 if (block_last_index[i] >= 0)
158 276433 cbp |= 1 << (5 - i);
159 105360 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 796986 static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
168 {
169 796986 MPVEncContext *const s = &h->s.s;
170 int level, run, i, j, last_index, last_non_zero;
171
172
2/2
✓ Branch 0 taken 169980 times.
✓ Branch 1 taken 627006 times.
 796986 if (s->c.mb_intra) {
173 /* DC coef */
174 169980 level = block[0];
175 /* 255 cannot be represented, so we clamp */
176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 169980 times.
 169980 if (level > 254) {
177 ✗ level = 254;
178 ✗ block[0] = 254;
179 }
180 /* 0 cannot be represented also */
181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 169980 times.
 169980 else if (level < 1) {
182 ✗ level = 1;
183 ✗ block[0] = 1;
184 }
185
2/2
✓ Branch 0 taken 2035 times.
✓ Branch 1 taken 167945 times.
 169980 if (level == 128)
186 2035 put_bits(&s->pb, 8, 0xff);
187 else
188 167945 put_bits(&s->pb, 8, level);
189 169980 i = 1;
190
4/4
✓ Branch 0 taken 562894 times.
✓ Branch 1 taken 64112 times.
✓ Branch 2 taken 67071 times.
✓ Branch 3 taken 495823 times.
 627006 } else if ((block[0] == 1 || block[0] == -1) &&
191
2/2
✓ Branch 0 taken 92217 times.
✓ Branch 1 taken 38966 times.
 131183 (s->c.block_last_index[n] > -1)) {
192 // special case
193
2/2
✓ Branch 0 taken 44668 times.
✓ Branch 1 taken 47549 times.
 92217 put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
194 92217 i = 1;
195 } else {
196 534789 i = 0;
197 }
198
199 /* AC coefs */
200 796986 last_index = s->c.block_last_index[n];
201 796986 last_non_zero = i - 1;
202
2/2
✓ Branch 0 taken 8994951 times.
✓ Branch 1 taken 796986 times.
 9791937 for (; i <= last_index; i++) {
203 8994951 j = s->c.intra_scantable.permutated[i];
204 8994951 level = block[j];
205
2/2
✓ Branch 0 taken 2936627 times.
✓ Branch 1 taken 6058324 times.
 8994951 if (level) {
206 2936627 run = i - last_non_zero - 1;
207
208
2/2
✓ Branch 0 taken 2928932 times.
✓ Branch 1 taken 7695 times.
 2936627 if (run <= H261_MAX_RUN &&
209
2/2
✓ Branch 0 taken 2925517 times.
✓ Branch 1 taken 3415 times.
 2928932 (unsigned)(level + H261_MAX_LEVEL) <= 2 * H261_MAX_LEVEL &&
210
2/2
✓ Branch 0 taken 2894680 times.
✓ Branch 1 taken 30837 times.
 2925517 vlc_lut[run][level + H261_MAX_LEVEL].len) {
211 2894680 put_bits(&s->pb, vlc_lut[run][level + H261_MAX_LEVEL].len,
212 2894680 vlc_lut[run][level + H261_MAX_LEVEL].code);
213 } else {
214 /* Escape */
215 41947 put_bits(&s->pb, 6 + 6, (1 << 6) | run);
216 av_assert1(level != 0);
217 av_assert1(FFABS(level) <= 127);
218 41947 put_sbits(&s->pb, 8, level);
219 }
220 2936627 last_non_zero = i;
221 }
222 }
223
2/2
✓ Branch 0 taken 446413 times.
✓ Branch 1 taken 350573 times.
 796986 if (last_index > -1)
224 446413 put_bits(&s->pb, 2, 0x2); // EOB
225 796986 }
226
227 133690 static void h261_encode_mb(MPVEncContext *const s, int16_t block[6][64],
228 int motion_x, int motion_y)
229 {
230 /* The following is only allowed because this encoder
231 * does not use slice threading. */
232 133690 H261EncContext *const h = (H261EncContext *)s;
233 int mvd, mv_diff_x, mv_diff_y, i, cbp;
234 133690 cbp = 63; // avoid warning
235 133690 mvd = 0;
236
237 133690 s->c.mtype = 0;
238
239
2/2
✓ Branch 0 taken 105360 times.
✓ Branch 1 taken 28330 times.
 133690 if (!s->c.mb_intra) {
240 /* compute cbp */
241 105360 cbp = get_cbp(s->c.block_last_index);
242
243 /* mvd indicates if this block is motion compensated */
244 105360 mvd = motion_x | motion_y;
245
246
2/2
✓ Branch 0 taken 859 times.
✓ Branch 1 taken 104501 times.
 105360 if ((cbp | mvd) == 0) {
247 /* skip macroblock */
248 859 s->mb_skip_run++;
249 859 s->c.last_mv[0][0][0] = 0;
250 859 s->c.last_mv[0][0][1] = 0;
251 859 s->c.qscale -= s->dquant;
252 859 return;
253 }
254 }
255
256 /* MB is not skipped, encode MBA */
257 132831 put_bits(&s->pb,
258 132831 ff_h261_mba_bits[s->mb_skip_run],
259 132831 ff_h261_mba_code[s->mb_skip_run]);
260 132831 s->mb_skip_run = 0;
261
262 /* calculate MTYPE */
263
2/2
✓ Branch 0 taken 104501 times.
✓ Branch 1 taken 28330 times.
 132831 if (!s->c.mb_intra) {
264 104501 s->c.mtype++;
265
266
4/4
✓ Branch 0 taken 3516 times.
✓ Branch 1 taken 100985 times.
✓ Branch 2 taken 1813 times.
✓ Branch 3 taken 1703 times.
 104501 if (mvd || s->loop_filter)
267 102798 s->c.mtype += 3;
268
2/2
✓ Branch 0 taken 51663 times.
✓ Branch 1 taken 52838 times.
 104501 if (s->loop_filter)
269 51663 s->c.mtype += 3;
270
2/2
✓ Branch 0 taken 85004 times.
✓ Branch 1 taken 19497 times.
 104501 if (cbp)
271 85004 s->c.mtype++;
272 av_assert1(s->c.mtype > 1);
273 }
274
275
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 132831 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 132831 if (s->dquant && cbp) {
276 ✗ s->c.mtype++;
277 } else
278 132831 s->c.qscale -= s->dquant;
279
280 132831 put_bits(&s->pb,
281 132831 ff_h261_mtype_bits[s->c.mtype],
282 132831 ff_h261_mtype_code[s->c.mtype]);
283
284 132831 s->c.mtype = ff_h261_mtype_map[s->c.mtype];
285
286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 132831 times.
 132831 if (IS_QUANT(s->c.mtype)) {
287 ✗ ff_set_qscale(&s->c, s->c.qscale + s->dquant);
288 ✗ put_bits(&s->pb, 5, s->c.qscale);
289 }
290
291
2/2
✓ Branch 0 taken 102798 times.
✓ Branch 1 taken 30033 times.
 132831 if (IS_16X16(s->c.mtype)) {
292 102798 mv_diff_x = (motion_x >> 1) - s->c.last_mv[0][0][0];
293 102798 mv_diff_y = (motion_y >> 1) - s->c.last_mv[0][0][1];
294 102798 s->c.last_mv[0][0][0] = (motion_x >> 1);
295 102798 s->c.last_mv[0][0][1] = (motion_y >> 1);
296 102798 h261_encode_motion(&s->pb, mv_diff_x);
297 102798 h261_encode_motion(&s->pb, mv_diff_y);
298 }
299
300
2/2
✓ Branch 0 taken 85004 times.
✓ Branch 1 taken 47827 times.
 132831 if (HAS_CBP(s->c.mtype)) {
301 av_assert1(cbp > 0);
302 85004 put_bits(&s->pb,
303 85004 ff_h261_cbp_tab[cbp - 1][1],
304 85004 ff_h261_cbp_tab[cbp - 1][0]);
305 }
306
2/2
✓ Branch 0 taken 796986 times.
✓ Branch 1 taken 132831 times.
 929817 for (i = 0; i < 6; i++)
307 /* encode each block */
308 796986 h261_encode_block(h, block[i], i);
309
310
2/2
✓ Branch 0 taken 30033 times.
✓ Branch 1 taken 102798 times.
 132831 if (!IS_16X16(s->c.mtype)) {
311 30033 s->c.last_mv[0][0][0] = 0;
312 30033 s->c.last_mv[0][0][1] = 0;
313 }
314 }
315
316 6 static av_cold void h261_encode_init_static(void)
317 {
318 6 uint8_t (*const mv_codes)[2] = h261_mv_codes + MV_TAB_OFFSET;
319 6 memset(uni_h261_rl_len, H261_ESC_LEN, sizeof(uni_h261_rl_len));
320 6 memset(uni_h261_rl_len_last, H261_ESC_LEN + 2 /* EOB */, sizeof(uni_h261_rl_len_last));
321
322 // The following loop is over the ordinary elements, not EOB or escape.
323
2/2
✓ Branch 0 taken 378 times.
✓ Branch 1 taken 6 times.
 384 for (size_t i = 1; i < FF_ARRAY_ELEMS(ff_h261_tcoeff_vlc) - 1; i++) {
324 378 unsigned run = ff_h261_tcoeff_run[i];
325 378 unsigned level = ff_h261_tcoeff_level[i];
326 378 unsigned len = ff_h261_tcoeff_vlc[i][1] + 1 /* sign */;
327 378 unsigned code = ff_h261_tcoeff_vlc[i][0];
328
329 378 vlc_lut[run][H261_MAX_LEVEL + level] = (struct VLCLUT){ len, code << 1 };
330 378 vlc_lut[run][H261_MAX_LEVEL - level] = (struct VLCLUT){ len, (code << 1) | 1 };
331
332 378 uni_h261_rl_len [UNI_AC_ENC_INDEX(run, 64 + level)] = len;
333 378 uni_h261_rl_len [UNI_AC_ENC_INDEX(run, 64 - level)] = len;
334 378 uni_h261_rl_len_last[UNI_AC_ENC_INDEX(run, 64 + level)] = len + 2;
335 378 uni_h261_rl_len_last[UNI_AC_ENC_INDEX(run, 64 - level)] = len + 2;
336 }
337
338 6 for (ptrdiff_t i = 1;; i++) {
339 // sign-one MV codes; diff -16..-1, 16..31
340 96 mv_codes[32 - i][0] = mv_codes[-i][0] = (ff_h261_mv_tab[i][0] << 1) | 1 /* sign */;
341 96 mv_codes[32 - i][1] = mv_codes[-i][1] = ff_h261_mv_tab[i][1] + 1;
342
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 90 times.
 96 if (i == 16)
343 6 break;
344 // sign-zero MV codes: diff -31..-17, 1..15
345 90 mv_codes[i][0] = mv_codes[i - 32][0] = ff_h261_mv_tab[i][0] << 1;
346 90 mv_codes[i][1] = mv_codes[i - 32][1] = ff_h261_mv_tab[i][1] + 1;
347 }
348 // MV code for difference zero; has no sign
349 6 mv_codes[0][0] = 1;
350 6 mv_codes[0][1] = 1;
351 6 }
352
353 6 static av_cold int h261_encode_init(AVCodecContext *avctx)
354 {
355 static AVOnce init_static_once = AV_ONCE_INIT;
356 6 H261EncContext *const h = avctx->priv_data;
357 6 MPVEncContext *const s = &h->s.s;
358
359
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 6 if (avctx->width == 176 && avctx->height == 144) {
360 ✗ h->format = H261_QCIF;
361
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 6 } else if (avctx->width == 352 && avctx->height == 288) {
362 6 h->format = H261_CIF;
363 } else {
364 ✗ av_log(avctx, AV_LOG_ERROR,
365 "The specified picture size of %dx%d is not valid for the "
366 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
367 avctx->width, avctx->height);
368 ✗ return AVERROR(EINVAL);
369 }
370 6 h->s.encode_picture_header = h261_encode_picture_header;
371 6 s->encode_mb = h261_encode_mb;
372
373 6 s->min_qcoeff = -127;
374 6 s->max_qcoeff = 127;
375 6 s->ac_esc_length = H261_ESC_LEN;
376
377 6 s->me.mv_penalty = mv_penalty;
378
379 6 s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
380 6 s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len_last;
381 6 ff_thread_once(&init_static_once, h261_encode_init_static);
382
383 6 return ff_mpv_encode_init(avctx);
384 }
385
386 const FFCodec ff_h261_encoder = {
387 .p.name = "h261",
388 CODEC_LONG_NAME("H.261"),
389 .p.type = AVMEDIA_TYPE_VIDEO,
390 .p.id = AV_CODEC_ID_H261,
391 .p.priv_class = &ff_mpv_enc_class,
392 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
393 .priv_data_size = sizeof(H261EncContext),
394 .init = h261_encode_init,
395 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
396 .close = ff_mpv_encode_end,
397 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
398 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
399 .color_ranges = AVCOL_RANGE_MPEG,
400 };
401