GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ituh263enc.c Lines: 380 445 85.4 %
Date: 2019-11-22 03:34:36 Branches: 200 260 76.9 %

Line Branch Exec Source
1
/*
2
 * ITU H.263 bitstream encoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * H.263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P
6
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24
25
/**
26
 * @file
27
 * H.263 bitstream encoder.
28
 */
29
30
#include <limits.h>
31
32
#include "libavutil/attributes.h"
33
#include "avcodec.h"
34
#include "mpegvideo.h"
35
#include "mpegvideodata.h"
36
#include "h263.h"
37
#include "h263data.h"
38
#include "mathops.h"
39
#include "mpegutils.h"
40
#include "flv.h"
41
#include "mpeg4video.h"
42
#include "internal.h"
43
44
/**
45
 * Table of number of bits a motion vector component needs.
46
 */
47
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
48
49
/**
50
 * Minimal fcode that a motion vector component would need.
51
 */
52
static uint8_t fcode_tab[MAX_MV*2+1];
53
54
/**
55
 * Minimal fcode that a motion vector component would need in umv.
56
 * All entries in this table are 1.
57
 */
58
static uint8_t umv_fcode_tab[MAX_MV*2+1];
59
60
//unified encoding tables for run length encoding of coefficients
61
//unified in the sense that the specification specifies the encoding in several steps.
62
static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
63
static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
64
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
65
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
66
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
67
68
static const uint8_t wrong_run[102] = {
69
 1,  2,  3,  5,  4, 10,  9,  8,
70
11, 15, 17, 16, 23, 22, 21, 20,
71
19, 18, 25, 24, 27, 26, 11,  7,
72
 6,  1,  2, 13,  2,  2,  2,  2,
73
 6, 12,  3,  9,  1,  3,  4,  3,
74
 7,  4,  1,  1,  5,  5, 14,  6,
75
 1,  7,  1,  8,  1,  1,  1,  1,
76
10,  1,  1,  5,  9, 17, 25, 24,
77
29, 33, 32, 41,  2, 23, 28, 31,
78
 3, 22, 30,  4, 27, 40,  8, 26,
79
 6, 39,  7, 38, 16, 37, 15, 10,
80
11, 12, 13, 14,  1, 21, 20, 18,
81
19,  2,  1, 34, 35, 36
82
};
83
84
/**
85
 * Return the 4 bit value that specifies the given aspect ratio.
86
 * This may be one of the standard aspect ratios or it specifies
87
 * that the aspect will be stored explicitly later.
88
 */
89
213
av_const int ff_h263_aspect_to_info(AVRational aspect){
90
    int i;
91
92

213
    if(aspect.num==0 || aspect.den==0) aspect= (AVRational){1,1};
93
94
213
    for(i=1; i<6; i++){
95
213
        if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
96
213
            return i;
97
        }
98
    }
99
100
    return FF_ASPECT_EXTENDED;
101
}
102
103
450
void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
104
{
105
    int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
106
450
    int best_clock_code=1;
107
450
    int best_divisor=60;
108
450
    int best_error= INT_MAX;
109
110
450
    if(s->h263_plus){
111
450
        for(i=0; i<2; i++){
112
            int div, error;
113
300
            div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
114
300
            div= av_clip(div, 1, 127);
115
300
            error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
116
300
            if(error < best_error){
117
150
                best_error= error;
118
150
                best_divisor= div;
119
150
                best_clock_code= i;
120
            }
121
        }
122
    }
123

450
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
124
450
    coded_frame_rate= 1800000;
125
450
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
126
127
450
    avpriv_align_put_bits(&s->pb);
128
129
    /* Update the pointer to last GOB */
130
450
    s->ptr_lastgob = put_bits_ptr(&s->pb);
131
450
    put_bits(&s->pb, 22, 0x20); /* PSC */
132
450
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
133
450
                         (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
134
450
    put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
135
136
450
    put_bits(&s->pb, 1, 1);     /* marker */
137
450
    put_bits(&s->pb, 1, 0);     /* H.263 id */
138
450
    put_bits(&s->pb, 1, 0);     /* split screen off */
139
450
    put_bits(&s->pb, 1, 0);     /* camera  off */
140
450
    put_bits(&s->pb, 1, 0);     /* freeze picture release off */
141
142
450
    format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);
143
450
    if (!s->h263_plus) {
144
        /* H.263v1 */
145
300
        put_bits(&s->pb, 3, format);
146
300
        put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
147
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
148
        of H.263v1 UMV implies to check the predicted MV after
149
        calculation of the current MB to see if we're on the limits */
150
300
        put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
151
300
        put_bits(&s->pb, 1, 0);         /* SAC: off */
152
300
        put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
153
300
        put_bits(&s->pb, 1, 0);         /* only I/P-frames, no PB-frame */
154
300
        put_bits(&s->pb, 5, s->qscale);
155
300
        put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
156
    } else {
157
150
        int ufep=1;
158
        /* H.263v2 */
159
        /* H.263 Plus PTYPE */
160
161
150
        put_bits(&s->pb, 3, 7);
162
150
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
163
150
        if (format == 8)
164
            put_bits(&s->pb,3,6); /* Custom Source Format */
165
        else
166
150
            put_bits(&s->pb, 3, format);
167
168
150
        put_bits(&s->pb,1, s->custom_pcf);
169
150
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
170
150
        put_bits(&s->pb,1,0); /* SAC: off */
171
150
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
172
150
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
173
150
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
174
150
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
175
150
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
176
150
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
177
150
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
178
150
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
179
150
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
180
150
        put_bits(&s->pb,3,0); /* Reserved */
181
182
150
        put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
183
184
150
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
185
150
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
186
150
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
187
150
        put_bits(&s->pb,2,0); /* Reserved */
188
150
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
189
190
        /* This should be here if PLUSPTYPE */
191
150
        put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
192
193
150
        if (format == 8) {
194
            /* Custom Picture Format (CPFMT) */
195
            s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
196
197
            put_bits(&s->pb,4,s->aspect_ratio_info);
198
            put_bits(&s->pb,9,(s->width >> 2) - 1);
199
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
200
            put_bits(&s->pb,9,(s->height >> 2));
201
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
202
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
203
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
204
            }
205
        }
206
150
        if(s->custom_pcf){
207
150
            if(ufep){
208
150
                put_bits(&s->pb, 1, best_clock_code);
209
150
                put_bits(&s->pb, 7, best_divisor);
210
            }
211
150
            put_sbits(&s->pb, 2, temp_ref>>8);
212
        }
213
214
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
215
150
        if (s->umvplus)
216
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
217
//FIXME check actual requested range
218
150
            put_bits(&s->pb,2,1); /* unlimited */
219
150
        if(s->h263_slice_structured)
220
            put_bits(&s->pb,2,0); /* no weird submodes */
221
222
150
        put_bits(&s->pb, 5, s->qscale);
223
    }
224
225
450
    put_bits(&s->pb, 1, 0);     /* no PEI */
226
227
450
    if(s->h263_slice_structured){
228
        put_bits(&s->pb, 1, 1);
229
230
        av_assert1(s->mb_x == 0 && s->mb_y == 0);
231
        ff_h263_encode_mba(s);
232
233
        put_bits(&s->pb, 1, 1);
234
    }
235
450
}
236
237
/**
238
 * Encode a group of blocks header.
239
 */
240
2544
void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
241
{
242
2544
    put_bits(&s->pb, 17, 1); /* GBSC */
243
244
2544
    if(s->h263_slice_structured){
245
        put_bits(&s->pb, 1, 1);
246
247
        ff_h263_encode_mba(s);
248
249
        if(s->mb_num > 1583)
250
            put_bits(&s->pb, 1, 1);
251
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
252
        put_bits(&s->pb, 1, 1);
253
        put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
254
    }else{
255
2544
        int gob_number= mb_line / s->gob_index;
256
257
2544
        put_bits(&s->pb, 5, gob_number); /* GN */
258
2544
        put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
259
2544
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
260
    }
261
2544
}
262
263
/**
264
 * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
265
 */
266
400
void ff_clean_h263_qscales(MpegEncContext *s){
267
    int i;
268
400
    int8_t * const qscale_table = s->current_picture.qscale_table;
269
270
400
    ff_init_qscale_tab(s);
271
272
119700
    for(i=1; i<s->mb_num; i++){
273
119300
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
274
4341
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
275
    }
276
119700
    for(i=s->mb_num-2; i>=0; i--){
277
119300
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
278
3504
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
279
    }
280
281
400
    if(s->codec_id != AV_CODEC_ID_H263P){
282
119700
        for(i=1; i<s->mb_num; i++){
283
119300
            int mb_xy= s->mb_index2xy[i];
284
285

119300
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
286
7334
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
287
            }
288
        }
289
    }
290
400
}
291
292
static const int dquant_code[5]= {1,0,9,2,3};
293
294
/**
295
 * Encode an 8x8 block.
296
 * @param block the 8x8 block
297
 * @param n block index (0-3 are luma, 4-5 are chroma)
298
 */
299
2388636
static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
300
{
301
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
302
    RLTable *rl;
303
304
2388636
    rl = &ff_h263_rl_inter;
305

2388636
    if (s->mb_intra && !s->h263_aic) {
306
        /* DC coef */
307
266694
        level = block[0];
308
        /* 255 cannot be represented, so we clamp */
309
266694
        if (level > 254) {
310
            level = 254;
311
            block[0] = 254;
312
        }
313
        /* 0 cannot be represented also */
314
266694
        else if (level < 1) {
315
            level = 1;
316
            block[0] = 1;
317
        }
318
266694
        if (level == 128) //FIXME check rv10
319
5826
            put_bits(&s->pb, 8, 0xff);
320
        else
321
260868
            put_bits(&s->pb, 8, level);
322
266694
        i = 1;
323
    } else {
324
2121942
        i = 0;
325

2121942
        if (s->h263_aic && s->mb_intra)
326
82098
            rl = &ff_rl_intra_aic;
327
328

2121942
        if(s->alt_inter_vlc && !s->mb_intra){
329
309894
            int aic_vlc_bits=0;
330
309894
            int inter_vlc_bits=0;
331
309894
            int wrong_pos=-1;
332
            int aic_code;
333
334
309894
            last_index = s->block_last_index[n];
335
309894
            last_non_zero = i - 1;
336
10126994
            for (; i <= last_index; i++) {
337
9817100
                j = s->intra_scantable.permutated[i];
338
9817100
                level = block[j];
339
9817100
                if (level) {
340
3646040
                    run = i - last_non_zero - 1;
341
3646040
                    last = (i == last_index);
342
343
3646040
                    if(level<0) level= -level;
344
345
3646040
                    code = get_rl_index(rl, last, run, level);
346
3646040
                    aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
347
3646040
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
348
3646040
                    aic_vlc_bits   += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
349
350
3646040
                    if (code == rl->n) {
351
238217
                        inter_vlc_bits += 1+6+8-1;
352
                    }
353
3646040
                    if (aic_code == ff_rl_intra_aic.n) {
354
160580
                        aic_vlc_bits += 1+6+8-1;
355
160580
                        wrong_pos += run + 1;
356
                    }else
357
3485460
                        wrong_pos += wrong_run[aic_code];
358
3646040
                    last_non_zero = i;
359
                }
360
            }
361
309894
            i = 0;
362

309894
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
363
66459
                rl = &ff_rl_intra_aic;
364
        }
365
    }
366
367
    /* AC coefs */
368
2388636
    last_index = s->block_last_index[n];
369
2388636
    last_non_zero = i - 1;
370
39717944
    for (; i <= last_index; i++) {
371
37329308
        j = s->intra_scantable.permutated[i];
372
37329308
        level = block[j];
373
37329308
        if (level) {
374
11712914
            run = i - last_non_zero - 1;
375
11712914
            last = (i == last_index);
376
11712914
            sign = 0;
377
11712914
            slevel = level;
378
11712914
            if (level < 0) {
379
5838423
                sign = 1;
380
5838423
                level = -level;
381
            }
382
11712914
            code = get_rl_index(rl, last, run, level);
383
11712914
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
384
11712914
            if (code == rl->n) {
385
590306
              if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
386
402806
                put_bits(&s->pb, 1, last);
387
402806
                put_bits(&s->pb, 6, run);
388
389
                av_assert2(slevel != 0);
390
391
402806
                if(level < 128)
392
400394
                    put_sbits(&s->pb, 8, slevel);
393
                else{
394
2412
                    put_bits(&s->pb, 8, 128);
395
2412
                    put_sbits(&s->pb, 5, slevel);
396
2412
                    put_sbits(&s->pb, 6, slevel>>5);
397
                }
398
              }else{
399
187500
                    ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
400
              }
401
            } else {
402
11122608
                put_bits(&s->pb, 1, sign);
403
            }
404
11712914
            last_non_zero = i;
405
        }
406
    }
407
2388636
}
408
409
/* Encode MV differences on H.263+ with Unrestricted MV mode */
410
103298
static void h263p_encode_umotion(PutBitContext *pb, int val)
411
{
412
103298
    short sval = 0;
413
103298
    short i = 0;
414
103298
    short n_bits = 0;
415
    short temp_val;
416
103298
    int code = 0;
417
    int tcode;
418
419
103298
    if ( val == 0)
420
51255
        put_bits(pb, 1, 1);
421
52043
    else if (val == 1)
422
12904
        put_bits(pb, 3, 0);
423
39139
    else if (val == -1)
424
20988
        put_bits(pb, 3, 2);
425
    else {
426
427
18151
        sval = ((val < 0) ? (short)(-val):(short)val);
428
18151
        temp_val = sval;
429
430
65061
        while (temp_val != 0) {
431
46910
            temp_val = temp_val >> 1;
432
46910
            n_bits++;
433
        }
434
435
18151
        i = n_bits - 1;
436
46910
        while (i > 0) {
437
28759
            tcode = (sval & (1 << (i-1))) >> (i-1);
438
28759
            tcode = (tcode << 1) | 1;
439
28759
            code = (code << 2) | tcode;
440
28759
            i--;
441
        }
442
18151
        code = ((code << 1) | (val < 0)) << 1;
443
18151
        put_bits(pb, (2*n_bits)+1, code);
444
    }
445
103298
}
446
447
428550
void ff_h263_encode_mb(MpegEncContext * s,
448
                       int16_t block[6][64],
449
                       int motion_x, int motion_y)
450
{
451
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
452
    int16_t pred_dc;
453
    int16_t rec_intradc[6];
454
    int16_t *dc_ptr[6];
455
428550
    const int interleaved_stats = s->avctx->flags & AV_CODEC_FLAG_PASS1;
456
457
428550
    if (!s->mb_intra) {
458
        /* compute cbp */
459
370418
        cbp= get_p_cbp(s, block, motion_x, motion_y);
460
461
370418
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
462
            /* skip macroblock */
463
30444
            put_bits(&s->pb, 1, 1);
464
30444
            if(interleaved_stats){
465
                s->misc_bits++;
466
                s->last_bits++;
467
            }
468
30444
            s->skip_count++;
469
470
30444
            return;
471
        }
472
339974
        put_bits(&s->pb, 1, 0);         /* mb coded */
473
474
339974
        cbpc = cbp & 3;
475
339974
        cbpy = cbp >> 2;
476

339974
        if(s->alt_inter_vlc==0 || cbpc!=3)
477
302130
            cbpy ^= 0xF;
478
339974
        if(s->dquant) cbpc+= 8;
479
339974
        if(s->mv_type==MV_TYPE_16X16){
480
339974
            put_bits(&s->pb,
481
339974
                    ff_h263_inter_MCBPC_bits[cbpc],
482
339974
                    ff_h263_inter_MCBPC_code[cbpc]);
483
484
339974
            put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
485
339974
            if(s->dquant)
486
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
487
488
339974
            if(interleaved_stats){
489
                s->misc_bits+= get_bits_diff(s);
490
            }
491
492
            /* motion vectors: 16x16 mode */
493
339974
            ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
494
495
339974
            if (!s->umvplus) {
496
288325
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
497
                                                motion_y - pred_y, 1);
498
            }
499
            else {
500
51649
                h263p_encode_umotion(&s->pb, motion_x - pred_x);
501
51649
                h263p_encode_umotion(&s->pb, motion_y - pred_y);
502

51649
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
503
                    /* To prevent Start Code emulation */
504
340
                    put_bits(&s->pb,1,1);
505
            }
506
        }else{
507
            put_bits(&s->pb,
508
                    ff_h263_inter_MCBPC_bits[cbpc+16],
509
                    ff_h263_inter_MCBPC_code[cbpc+16]);
510
            put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
511
            if(s->dquant)
512
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
513
514
            if(interleaved_stats){
515
                s->misc_bits+= get_bits_diff(s);
516
            }
517
518
            for(i=0; i<4; i++){
519
                /* motion vectors: 8x8 mode*/
520
                ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
521
522
                motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
523
                motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
524
                if (!s->umvplus) {
525
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
526
                                                    motion_y - pred_y, 1);
527
                }
528
                else {
529
                    h263p_encode_umotion(&s->pb, motion_x - pred_x);
530
                    h263p_encode_umotion(&s->pb, motion_y - pred_y);
531
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
532
                        /* To prevent Start Code emulation */
533
                        put_bits(&s->pb,1,1);
534
                }
535
            }
536
        }
537
538
339974
        if(interleaved_stats){
539
            s->mv_bits+= get_bits_diff(s);
540
        }
541
    } else {
542
        av_assert2(s->mb_intra);
543
544
58132
        cbp = 0;
545
58132
        if (s->h263_aic) {
546
            /* Predict DC */
547
95781
            for(i=0; i<6; i++) {
548
82098
                int16_t level = block[i][0];
549
                int scale;
550
551
82098
                if(i<4) scale= s->y_dc_scale;
552
27366
                else    scale= s->c_dc_scale;
553
554
82098
                pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
555
82098
                level -= pred_dc;
556
                /* Quant */
557
82098
                if (level >= 0)
558
43407
                    level = (level + (scale>>1))/scale;
559
                else
560
38691
                    level = (level - (scale>>1))/scale;
561
562
82098
                if(!s->modified_quant){
563
                    if (level < -127)
564
                        level = -127;
565
                    else if (level > 127)
566
                        level = 127;
567
                }
568
569
82098
                block[i][0] = level;
570
                /* Reconstruction */
571
82098
                rec_intradc[i] = scale*level + pred_dc;
572
                /* Oddify */
573
82098
                rec_intradc[i] |= 1;
574
                //if ((rec_intradc[i] % 2) == 0)
575
                //    rec_intradc[i]++;
576
                /* Clipping */
577
82098
                if (rec_intradc[i] < 0)
578
                    rec_intradc[i] = 0;
579
82098
                else if (rec_intradc[i] > 2047)
580
                    rec_intradc[i] = 2047;
581
582
                /* Update AC/DC tables */
583
82098
                *dc_ptr[i] = rec_intradc[i];
584
                /* AIC can change CBP */
585
82098
                if (s->block_last_index[i] > 0 ||
586

6224
                    (s->block_last_index[i] == 0 && level !=0))
587
80847
                    cbp |= 1 << (5 - i);
588
            }
589
        }else{
590
311143
            for(i=0; i<6; i++) {
591
                /* compute cbp */
592
266694
                if (s->block_last_index[i] >= 1)
593
206994
                    cbp |= 1 << (5 - i);
594
            }
595
        }
596
597
58132
        cbpc = cbp & 3;
598
58132
        if (s->pict_type == AV_PICTURE_TYPE_I) {
599
45249
            if(s->dquant) cbpc+=4;
600
45249
            put_bits(&s->pb,
601
45249
                ff_h263_intra_MCBPC_bits[cbpc],
602
45249
                ff_h263_intra_MCBPC_code[cbpc]);
603
        } else {
604
12883
            if(s->dquant) cbpc+=8;
605
12883
            put_bits(&s->pb, 1, 0);     /* mb coded */
606
12883
            put_bits(&s->pb,
607
12883
                ff_h263_inter_MCBPC_bits[cbpc + 4],
608
12883
                ff_h263_inter_MCBPC_code[cbpc + 4]);
609
        }
610
58132
        if (s->h263_aic) {
611
            /* XXX: currently, we do not try to use ac prediction */
612
13683
            put_bits(&s->pb, 1, 0);     /* no AC prediction */
613
        }
614
58132
        cbpy = cbp >> 2;
615
58132
        put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
616
58132
        if(s->dquant)
617
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
618
619
58132
        if(interleaved_stats){
620
            s->misc_bits+= get_bits_diff(s);
621
        }
622
    }
623
624
2786742
    for(i=0; i<6; i++) {
625
        /* encode each block */
626
2388636
        h263_encode_block(s, block[i], i);
627
628
        /* Update INTRADC for decoding */
629

2388636
        if (s->h263_aic && s->mb_intra) {
630
82098
            block[i][0] = rec_intradc[i];
631
632
        }
633
    }
634
635
398106
    if(interleaved_stats){
636
        if (!s->mb_intra) {
637
            s->p_tex_bits+= get_bits_diff(s);
638
            s->f_count++;
639
        }else{
640
            s->i_tex_bits+= get_bits_diff(s);
641
            s->i_count++;
642
        }
643
    }
644
}
645
646
5314892
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
647
{
648
    int range, bit_size, sign, code, bits;
649
650
5314892
    if (val == 0) {
651
        /* zero vector */
652
2219365
        code = 0;
653
2219365
        put_bits(pb, ff_mvtab[code][1], ff_mvtab[code][0]);
654
    } else {
655
3095527
        bit_size = f_code - 1;
656
3095527
        range = 1 << bit_size;
657
        /* modulo encoding */
658
3095527
        val = sign_extend(val, 6 + bit_size);
659
3095527
        sign = val>>31;
660
3095527
        val= (val^sign)-sign;
661
3095527
        sign&=1;
662
663
3095527
        val--;
664
3095527
        code = (val >> bit_size) + 1;
665
3095527
        bits = val & (range - 1);
666
667
3095527
        put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
668
3095527
        if (bit_size > 0) {
669
434215
            put_bits(pb, bit_size, bits);
670
        }
671
    }
672
5314892
}
673
674
113
static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
675
{
676
    int f_code;
677
    int mv;
678
679
904
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
680
12961326
        for(mv=-MAX_DMV; mv<=MAX_DMV; mv++){
681
            int len;
682
683
12960535
            if(mv==0) len= ff_mvtab[0][1];
684
            else{
685
                int val, bit_size, code;
686
687
12959744
                bit_size = f_code - 1;
688
689
12959744
                val=mv;
690
12959744
                if (val < 0)
691
6479872
                    val = -val;
692
12959744
                val--;
693
12959744
                code = (val >> bit_size) + 1;
694
12959744
                if(code<33){
695
918464
                    len= ff_mvtab[code][1] + 1 + bit_size;
696
                }else{
697
12041280
                    len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
698
                }
699
            }
700
701
12960535
            mv_penalty[f_code][mv+MAX_DMV]= len;
702
        }
703
    }
704
705
904
    for(f_code=MAX_FCODE; f_code>0; f_code--){
706
919255
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
707
918464
            fcode_tab[mv+MAX_MV]= f_code;
708
        }
709
    }
710
711
925922
    for(mv=0; mv<MAX_MV*2+1; mv++){
712
925809
        umv_fcode_tab[mv]= 1;
713
    }
714
113
}
715
716
226
static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
717
                                         uint8_t *len_tab)
718
{
719
    int slevel, run, last;
720
721
    av_assert0(MAX_LEVEL >= 64);
722
    av_assert0(MAX_RUN   >= 63);
723
724
29154
    for(slevel=-64; slevel<64; slevel++){
725
28928
        if(slevel==0) continue;
726
1865630
        for(run=0; run<64; run++){
727
5510784
            for(last=0; last<=1; last++){
728
3673856
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
729
3673856
                int level= slevel < 0 ? -slevel : slevel;
730
3673856
                int sign= slevel < 0 ? 1 : 0;
731
                int bits, len, code;
732
733
3673856
                len_tab[index]= 100;
734
735
                /* ESC0 */
736
3673856
                code= get_rl_index(rl, last, run, level);
737
3673856
                bits= rl->table_vlc[code][0];
738
3673856
                len=  rl->table_vlc[code][1];
739
3673856
                bits=bits*2+sign; len++;
740
741

3673856
                if(code!=rl->n && len < len_tab[index]){
742
46104
                    if(bits_tab) bits_tab[index]= bits;
743
46104
                    len_tab [index]= len;
744
                }
745
                /* ESC */
746
3673856
                bits= rl->table_vlc[rl->n][0];
747
3673856
                len = rl->table_vlc[rl->n][1];
748
3673856
                bits=bits*2+last; len++;
749
3673856
                bits=bits*64+run; len+=6;
750
3673856
                bits=bits*256+(level&0xff); len+=8;
751
752
3673856
                if(len < len_tab[index]){
753
3627752
                    if(bits_tab) bits_tab[index]= bits;
754
3627752
                    len_tab [index]= len;
755
                }
756
            }
757
        }
758
    }
759
226
}
760
761
113
av_cold void ff_h263_encode_init(MpegEncContext *s)
762
{
763
    static int done = 0;
764
765
113
    if (!done) {
766
113
        done = 1;
767
768
113
        ff_rl_init(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
769
113
        ff_rl_init(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
770
771
113
        init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
772
113
        init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
773
774
113
        init_mv_penalty_and_fcode(s);
775
    }
776
113
    s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
777
778
113
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
779
113
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
780
113
    if(s->h263_aic){
781
6
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
782
6
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
783
    }
784
113
    s->ac_esc_length= 7+1+6+8;
785
786
    // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
787

113
    switch(s->codec_id){
788
58
    case AV_CODEC_ID_MPEG4:
789
58
        s->fcode_tab= fcode_tab;
790
58
        break;
791
3
    case AV_CODEC_ID_H263P:
792
3
        if(s->umvplus)
793
3
            s->fcode_tab= umv_fcode_tab;
794
3
        if(s->modified_quant){
795
3
            s->min_qcoeff= -2047;
796
3
            s->max_qcoeff=  2047;
797
        }else{
798
            s->min_qcoeff= -127;
799
            s->max_qcoeff=  127;
800
        }
801
3
        break;
802
        // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
803
7
    case AV_CODEC_ID_FLV1:
804
7
        if (s->h263_flv > 1) {
805
7
            s->min_qcoeff= -1023;
806
7
            s->max_qcoeff=  1023;
807
        } else {
808
            s->min_qcoeff= -127;
809
            s->max_qcoeff=  127;
810
        }
811
7
        break;
812
45
    default: //nothing needed - default table already set in mpegvideo.c
813
45
        s->min_qcoeff= -127;
814
45
        s->max_qcoeff=  127;
815
    }
816
113
    if(s->h263_aic){
817
6
         s->y_dc_scale_table=
818
6
         s->c_dc_scale_table= ff_aic_dc_scale_table;
819
    }else{
820
107
        s->y_dc_scale_table=
821
107
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
822
    }
823
113
}
824
825
150
void ff_h263_encode_mba(MpegEncContext *s)
826
{
827
    int i, mb_pos;
828
829
450
    for(i=0; i<6; i++){
830
450
        if(s->mb_num-1 <= ff_mba_max[i]) break;
831
    }
832
150
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
833
150
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
834
150
}