GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/h261enc.c Lines: 194 206 94.2 %
Date: 2019-11-20 04:07:19 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 "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 [64*64*2*2];
38
#define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (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
    avpriv_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(RLTable *rl, uint32_t *bits_tab,
326
                                         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
av_cold void ff_h261_encode_init(MpegEncContext *s)
366
{
367
6
    ff_h261_common_init();
368
369
6
    s->min_qcoeff       = -127;
370
6
    s->max_qcoeff       = 127;
371
6
    s->y_dc_scale_table =
372
6
    s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
373
6
    s->ac_esc_length    = 6+6+8;
374
375
6
    init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, NULL, uni_h261_rl_len);
376
377
6
    s->intra_ac_vlc_length      = s->inter_ac_vlc_length      = uni_h261_rl_len;
378
6
    s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
379
6
}
380
381
static const AVClass h261_class = {
382
    .class_name = "h261 encoder",
383
    .item_name  = av_default_item_name,
384
    .option     = ff_mpv_generic_options,
385
    .version    = LIBAVUTIL_VERSION_INT,
386
};
387
388
AVCodec ff_h261_encoder = {
389
    .name           = "h261",
390
    .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
391
    .type           = AVMEDIA_TYPE_VIDEO,
392
    .id             = AV_CODEC_ID_H261,
393
    .priv_data_size = sizeof(H261Context),
394
    .init           = ff_mpv_encode_init,
395
    .encode2        = ff_mpv_encode_picture,
396
    .close          = ff_mpv_encode_end,
397
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
398
                                                     AV_PIX_FMT_NONE },
399
    .priv_class     = &h261_class,
400
};