FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/h261enc.c
Date: 2024-03-29 01:21:52
Exec Total Coverage
Lines: 197 209 94.3%
Functions: 10 10 100.0%
Branches: 88 104 84.6%

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 "mpegvideodata.h"
38 #include "mpegvideoenc.h"
39
40 static uint8_t uni_h261_rl_len [64*64*2*2];
41 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
42
43 typedef struct H261EncContext {
44 MpegEncContext s;
45
46 H261Context common;
47
48 int gob_number;
49 enum {
50 H261_QCIF = 0,
51 H261_CIF = 1,
52 } format;
53 } H261EncContext;
54
55 300 void ff_h261_encode_picture_header(MpegEncContext *s)
56 {
57 300 H261EncContext *const h = (H261EncContext *)s;
58 int temp_ref;
59
60 300 align_put_bits(&s->pb);
61
62 /* Update the pointer to last GOB */
63 300 s->ptr_lastgob = put_bits_ptr(&s->pb);
64
65 300 put_bits(&s->pb, 20, 0x10); /* PSC */
66
67 300 temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
68 300 (1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp
69 300 put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
70
71 300 put_bits(&s->pb, 1, 0); /* split screen off */
72 300 put_bits(&s->pb, 1, 0); /* camera off */
73 300 put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
74
75 300 put_bits(&s->pb, 1, h->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 h->gob_number = h->format - 1;
82 300 s->mb_skip_run = 0;
83 300 }
84
85 /**
86 * Encode a group of blocks header.
87 */
88 3600 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
89 {
90 3600 H261EncContext *const h = (H261EncContext *)s;
91
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3600 times.
3600 if (h->format == H261_QCIF) {
92 h->gob_number += 2; // QCIF
93 } else {
94 3600 h->gob_number++; // CIF
95 }
96 3600 put_bits(&s->pb, 16, 1); /* GBSC */
97 3600 put_bits(&s->pb, 4, h->gob_number); /* GN */
98 3600 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
99 3600 put_bits(&s->pb, 1, 0); /* no GEI */
100 3600 s->mb_skip_run = 0;
101 3600 s->last_mv[0][0][0] = 0;
102 3600 s->last_mv[0][0][1] = 0;
103 3600 }
104
105 118800 void ff_h261_reorder_mb_index(MpegEncContext *s)
106 {
107 118800 const H261EncContext *const h = (H261EncContext*)s;
108 118800 int index = s->mb_x + s->mb_y * s->mb_width;
109
110
2/2
✓ Branch 0 taken 10800 times.
✓ Branch 1 taken 108000 times.
118800 if (index % 11 == 0) {
111
2/2
✓ Branch 0 taken 3600 times.
✓ Branch 1 taken 7200 times.
10800 if (index % 33 == 0)
112 3600 h261_encode_gob_header(s, 0);
113 10800 s->last_mv[0][0][0] = 0;
114 10800 s->last_mv[0][0][1] = 0;
115 }
116
117 /* for CIF the GOB's are fragmented in the middle of a scanline
118 * that's why we need to adjust the x and y index of the macroblocks */
119
1/2
✓ Branch 0 taken 118800 times.
✗ Branch 1 not taken.
118800 if (h->format == H261_CIF) {
120 118800 s->mb_x = index % 11;
121 118800 index /= 11;
122 118800 s->mb_y = index % 3;
123 118800 index /= 3;
124 118800 s->mb_x += 11 * (index % 2);
125 118800 index /= 2;
126 118800 s->mb_y += 3 * index;
127
128 118800 ff_init_block_index(s);
129 118800 ff_update_block_index(s, 8, 0, 1);
130 }
131 118800 }
132
133 201048 static void h261_encode_motion(PutBitContext *pb, int val)
134 {
135 int sign, code;
136
2/2
✓ Branch 0 taken 113914 times.
✓ Branch 1 taken 87134 times.
201048 if (val == 0) {
137 113914 code = 0;
138 113914 put_bits(pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
139 } else {
140
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 87089 times.
87134 if (val > 15)
141 45 val -= 32;
142
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 87099 times.
87134 if (val < -16)
143 35 val += 32;
144 87134 sign = val < 0;
145
2/2
✓ Branch 0 taken 47447 times.
✓ Branch 1 taken 39687 times.
87134 code = sign ? -val : val;
146 87134 put_bits(pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
147 87134 put_bits(pb, 1, sign);
148 }
149 201048 }
150
151 104856 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
152 {
153 int i, cbp;
154 104856 cbp = 0;
155
2/2
✓ Branch 0 taken 629136 times.
✓ Branch 1 taken 104856 times.
733992 for (i = 0; i < 6; i++)
156
2/2
✓ Branch 0 taken 261040 times.
✓ Branch 1 taken 368096 times.
629136 if (s->block_last_index[i] >= 0)
157 261040 cbp |= 1 << (5 - i);
158 104856 return cbp;
159 }
160
161 /**
162 * Encode an 8x8 block.
163 * @param block the 8x8 block
164 * @param n block index (0-3 are luma, 4-5 are chroma)
165 */
166 796752 static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
167 {
168 796752 MpegEncContext *const s = &h->s;
169 int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
170 RLTable *rl;
171
172 796752 rl = &ff_h261_rl_tcoeff;
173
2/2
✓ Branch 0 taken 172932 times.
✓ Branch 1 taken 623820 times.
796752 if (s->mb_intra) {
174 /* DC coef */
175 172932 level = block[0];
176 /* 255 cannot be represented, so we clamp */
177
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 172932 times.
172932 if (level > 254) {
178 level = 254;
179 block[0] = 254;
180 }
181 /* 0 cannot be represented also */
182
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 172932 times.
172932 else if (level < 1) {
183 level = 1;
184 block[0] = 1;
185 }
186
2/2
✓ Branch 0 taken 2093 times.
✓ Branch 1 taken 170839 times.
172932 if (level == 128)
187 2093 put_bits(&s->pb, 8, 0xff);
188 else
189 170839 put_bits(&s->pb, 8, level);
190 172932 i = 1;
191
4/4
✓ Branch 0 taken 563387 times.
✓ Branch 1 taken 60433 times.
✓ Branch 2 taken 60856 times.
✓ Branch 3 taken 502531 times.
623820 } else if ((block[0] == 1 || block[0] == -1) &&
192
2/2
✓ Branch 0 taken 85981 times.
✓ Branch 1 taken 35308 times.
121289 (s->block_last_index[n] > -1)) {
193 // special case
194
2/2
✓ Branch 0 taken 42754 times.
✓ Branch 1 taken 43227 times.
85981 put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
195 85981 i = 1;
196 } else {
197 537839 i = 0;
198 }
199
200 /* AC coefs */
201 796752 last_index = s->block_last_index[n];
202 796752 last_non_zero = i - 1;
203
2/2
✓ Branch 0 taken 9349317 times.
✓ Branch 1 taken 796752 times.
10146069 for (; i <= last_index; i++) {
204 9349317 j = s->intra_scantable.permutated[i];
205 9349317 level = block[j];
206
2/2
✓ Branch 0 taken 2765550 times.
✓ Branch 1 taken 6583767 times.
9349317 if (level) {
207 2765550 run = i - last_non_zero - 1;
208 2765550 sign = 0;
209 2765550 slevel = level;
210
2/2
✓ Branch 0 taken 1382173 times.
✓ Branch 1 taken 1383377 times.
2765550 if (level < 0) {
211 1382173 sign = 1;
212 1382173 level = -level;
213 }
214 2765550 code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
215 run, level);
216
4/4
✓ Branch 0 taken 1461799 times.
✓ Branch 1 taken 1303751 times.
✓ Branch 2 taken 1458226 times.
✓ Branch 3 taken 3573 times.
2765550 if (run == 0 && level < 16)
217 1458226 code += 1;
218 2765550 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
219
2/2
✓ Branch 0 taken 72326 times.
✓ Branch 1 taken 2693224 times.
2765550 if (code == rl->n) {
220 72326 put_bits(&s->pb, 6, run);
221 av_assert1(slevel != 0);
222 av_assert1(level <= 127);
223 72326 put_sbits(&s->pb, 8, slevel);
224 } else {
225 2693224 put_bits(&s->pb, 1, sign);
226 }
227 2765550 last_non_zero = i;
228 }
229 }
230
2/2
✓ Branch 0 taken 433972 times.
✓ Branch 1 taken 362780 times.
796752 if (last_index > -1)
231 433972 put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
232 796752 }
233
234 133678 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
235 int motion_x, int motion_y)
236 {
237 /* The following is only allowed because this encoder
238 * does not use slice threading. */
239 133678 H261EncContext *const h = (H261EncContext *)s;
240 133678 H261Context *const com = &h->common;
241 int mvd, mv_diff_x, mv_diff_y, i, cbp;
242 133678 cbp = 63; // avoid warning
243 133678 mvd = 0;
244
245 133678 com->mtype = 0;
246
247
2/2
✓ Branch 0 taken 104856 times.
✓ Branch 1 taken 28822 times.
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
2/2
✓ Branch 0 taken 886 times.
✓ Branch 1 taken 103970 times.
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
2/2
✓ Branch 0 taken 103970 times.
✓ Branch 1 taken 28822 times.
132792 if (!s->mb_intra) {
273 103970 com->mtype++;
274
275
3/4
✓ Branch 0 taken 3446 times.
✓ Branch 1 taken 100524 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3446 times.
103970 if (mvd || s->loop_filter)
276 100524 com->mtype += 3;
277
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 103970 times.
103970 if (s->loop_filter)
278 com->mtype += 3;
279
2/2
✓ Branch 0 taken 84380 times.
✓ Branch 1 taken 19590 times.
103970 if (cbp)
280 84380 com->mtype++;
281 av_assert1(com->mtype > 1);
282 }
283
284
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 132792 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
132792 if (s->dquant && cbp) {
285 com->mtype++;
286 } else
287 132792 s->qscale -= s->dquant;
288
289 132792 put_bits(&s->pb,
290 132792 ff_h261_mtype_bits[com->mtype],
291 132792 ff_h261_mtype_code[com->mtype]);
292
293 132792 com->mtype = ff_h261_mtype_map[com->mtype];
294
295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 132792 times.
132792 if (IS_QUANT(com->mtype)) {
296 ff_set_qscale(s, s->qscale + s->dquant);
297 put_bits(&s->pb, 5, s->qscale);
298 }
299
300
2/2
✓ Branch 0 taken 100524 times.
✓ Branch 1 taken 32268 times.
132792 if (IS_16X16(com->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(&s->pb, mv_diff_x);
306 100524 h261_encode_motion(&s->pb, mv_diff_y);
307 }
308
309
2/2
✓ Branch 0 taken 84380 times.
✓ Branch 1 taken 48412 times.
132792 if (HAS_CBP(com->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
2/2
✓ Branch 0 taken 796752 times.
✓ Branch 1 taken 132792 times.
929544 for (i = 0; i < 6; i++)
316 /* encode each block */
317 796752 h261_encode_block(h, block[i], i);
318
319
2/2
✓ Branch 0 taken 32268 times.
✓ Branch 1 taken 100524 times.
132792 if (!IS_16X16(com->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
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 6 times.
774 for(slevel=-64; slevel<64; slevel++){
333
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 762 times.
768 if(slevel==0) continue;
334
2/2
✓ Branch 0 taken 48768 times.
✓ Branch 1 taken 762 times.
49530 for(run=0; run<64; run++){
335
2/2
✓ Branch 0 taken 97536 times.
✓ Branch 1 taken 48768 times.
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
2/2
✓ Branch 0 taken 48768 times.
✓ Branch 1 taken 48768 times.
97536 if(last)
346 48768 len += 2;
347
348
3/4
✓ Branch 0 taken 1512 times.
✓ Branch 1 taken 96024 times.
✓ Branch 2 taken 1512 times.
✗ Branch 3 not taken.
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
2/2
✓ Branch 0 taken 48768 times.
✓ Branch 1 taken 48768 times.
97536 if(last)
354 48768 len += 2;
355
356
2/2
✓ Branch 0 taken 97344 times.
✓ Branch 1 taken 192 times.
97536 if(len < len_tab[index]){
357 97344 len_tab [index]= len;
358 }
359 }
360 }
361 }
362 6 }
363
364 6 static av_cold void h261_encode_init_static(void)
365 {
366 static uint8_t h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
367
368 6 ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store);
369 6 init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len);
370 6 }
371
372 6 av_cold int ff_h261_encode_init(MpegEncContext *s)
373 {
374 6 H261EncContext *const h = (H261EncContext*)s;
375 static AVOnce init_static_once = AV_ONCE_INIT;
376
377
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
6 if (s->width == 176 && s->height == 144) {
378 h->format = H261_QCIF;
379
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
6 } else if (s->width == 352 && s->height == 288) {
380 6 h->format = H261_CIF;
381 } else {
382 av_log(s->avctx, AV_LOG_ERROR,
383 "The specified picture size of %dx%d is not valid for the "
384 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
385 s->width, s->height);
386 return AVERROR(EINVAL);
387 }
388 6 s->private_ctx = &h->common;
389
390 6 s->min_qcoeff = -127;
391 6 s->max_qcoeff = 127;
392 6 s->y_dc_scale_table =
393 6 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
394 6 s->ac_esc_length = 6+6+8;
395
396 6 s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
397 6 s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
398 6 ff_thread_once(&init_static_once, h261_encode_init_static);
399
400 6 return 0;
401 }
402
403 const FFCodec ff_h261_encoder = {
404 .p.name = "h261",
405 CODEC_LONG_NAME("H.261"),
406 .p.type = AVMEDIA_TYPE_VIDEO,
407 .p.id = AV_CODEC_ID_H261,
408 .p.priv_class = &ff_mpv_enc_class,
409 .priv_data_size = sizeof(H261EncContext),
410 .init = ff_mpv_encode_init,
411 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
412 .close = ff_mpv_encode_end,
413 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
414 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
415 AV_PIX_FMT_NONE },
416 .p.capabilities = AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
417 };
418