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 %

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 [64*64*2*2];
39
#define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (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
};