← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mplayer2/oneiric-proposed

« back to all changes in this revision

Viewing changes to ffmpeg-mt/libavcodec/ituh263enc.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 22:48:03 UTC
  • Revision ID: james.westby@ubuntu.com-20110320224803-kc2nlrxz6pcphmf1
Tags: upstream-2.0~rc2
Import upstream version 2.0~rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg-mt/libavcodec/ituh263enc.c
 
1
/*
 
2
 * ITU H263 bitstream encoder
 
3
 * Copyright (c) 2000,2001 Fabrice Bellard
 
4
 * H263+ 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
 * h263 bitstream encoder.
 
28
 */
 
29
 
 
30
//#define DEBUG
 
31
#include <limits.h>
 
32
 
 
33
#include "dsputil.h"
 
34
#include "avcodec.h"
 
35
#include "mpegvideo.h"
 
36
#include "h263.h"
 
37
#include "mathops.h"
 
38
#include "unary.h"
 
39
#include "flv.h"
 
40
#include "mpeg4video.h"
 
41
#include "internal.h"
 
42
 
 
43
//#undef NDEBUG
 
44
//#include <assert.h>
 
45
 
 
46
/**
 
47
 * Table of number of bits a motion vector component needs.
 
48
 */
 
49
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
 
50
 
 
51
/**
 
52
 * Minimal fcode that a motion vector component would need.
 
53
 */
 
54
static uint8_t fcode_tab[MAX_MV*2+1];
 
55
 
 
56
/**
 
57
 * Minimal fcode that a motion vector component would need in umv.
 
58
 * All entries in this table are 1.
 
59
 */
 
60
static uint8_t umv_fcode_tab[MAX_MV*2+1];
 
61
 
 
62
//unified encoding tables for run length encoding of coefficients
 
63
//unified in the sense that the specification specifies the encoding in several steps.
 
64
static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
 
65
static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
 
66
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
 
67
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
 
68
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
 
69
 
 
70
static const uint8_t wrong_run[102] = {
 
71
 1,  2,  3,  5,  4, 10,  9,  8,
 
72
11, 15, 17, 16, 23, 22, 21, 20,
 
73
19, 18, 25, 24, 27, 26, 11,  7,
 
74
 6,  1,  2, 13,  2,  2,  2,  2,
 
75
 6, 12,  3,  9,  1,  3,  4,  3,
 
76
 7,  4,  1,  1,  5,  5, 14,  6,
 
77
 1,  7,  1,  8,  1,  1,  1,  1,
 
78
10,  1,  1,  5,  9, 17, 25, 24,
 
79
29, 33, 32, 41,  2, 23, 28, 31,
 
80
 3, 22, 30,  4, 27, 40,  8, 26,
 
81
 6, 39,  7, 38, 16, 37, 15, 10,
 
82
11, 12, 13, 14,  1, 21, 20, 18,
 
83
19,  2,  1, 34, 35, 36
 
84
};
 
85
 
 
86
/**
 
87
 * Return the 4 bit value that specifies the given aspect ratio.
 
88
 * This may be one of the standard aspect ratios or it specifies
 
89
 * that the aspect will be stored explicitly later.
 
90
 */
 
91
av_const int ff_h263_aspect_to_info(AVRational aspect){
 
92
    int i;
 
93
 
 
94
    if(aspect.num==0) aspect= (AVRational){1,1};
 
95
 
 
96
    for(i=1; i<6; i++){
 
97
        if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
 
98
            return i;
 
99
        }
 
100
    }
 
101
 
 
102
    return FF_ASPECT_EXTENDED;
 
103
}
 
104
 
 
105
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
 
106
{
 
107
    int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
 
108
    int best_clock_code=1;
 
109
    int best_divisor=60;
 
110
    int best_error= INT_MAX;
 
111
 
 
112
    if(s->h263_plus){
 
113
        for(i=0; i<2; i++){
 
114
            int div, error;
 
115
            div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
 
116
            div= av_clip(div, 1, 127);
 
117
            error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
 
118
            if(error < best_error){
 
119
                best_error= error;
 
120
                best_divisor= div;
 
121
                best_clock_code= i;
 
122
            }
 
123
        }
 
124
    }
 
125
    s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
 
126
    coded_frame_rate= 1800000;
 
127
    coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
 
128
 
 
129
    align_put_bits(&s->pb);
 
130
 
 
131
    /* Update the pointer to last GOB */
 
132
    s->ptr_lastgob = put_bits_ptr(&s->pb);
 
133
    put_bits(&s->pb, 22, 0x20); /* PSC */
 
134
    temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
 
135
                         (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
 
136
    put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
 
137
 
 
138
    put_bits(&s->pb, 1, 1);     /* marker */
 
139
    put_bits(&s->pb, 1, 0);     /* h263 id */
 
140
    put_bits(&s->pb, 1, 0);     /* split screen off */
 
141
    put_bits(&s->pb, 1, 0);     /* camera  off */
 
142
    put_bits(&s->pb, 1, 0);     /* freeze picture release off */
 
143
 
 
144
    format = ff_match_2uint16(h263_format, FF_ARRAY_ELEMS(h263_format), s->width, s->height);
 
145
    if (!s->h263_plus) {
 
146
        /* H.263v1 */
 
147
        put_bits(&s->pb, 3, format);
 
148
        put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
 
149
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
 
150
        of H.263v1 UMV implies to check the predicted MV after
 
151
        calculation of the current MB to see if we're on the limits */
 
152
        put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
 
153
        put_bits(&s->pb, 1, 0);         /* SAC: off */
 
154
        put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
 
155
        put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
 
156
        put_bits(&s->pb, 5, s->qscale);
 
157
        put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
 
158
    } else {
 
159
        int ufep=1;
 
160
        /* H.263v2 */
 
161
        /* H.263 Plus PTYPE */
 
162
 
 
163
        put_bits(&s->pb, 3, 7);
 
164
        put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
 
165
        if (format == 8)
 
166
            put_bits(&s->pb,3,6); /* Custom Source Format */
 
167
        else
 
168
            put_bits(&s->pb, 3, format);
 
169
 
 
170
        put_bits(&s->pb,1, s->custom_pcf);
 
171
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
 
172
        put_bits(&s->pb,1,0); /* SAC: off */
 
173
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
 
174
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 
175
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
 
176
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
 
177
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 
178
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 
179
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
 
180
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
 
181
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 
182
        put_bits(&s->pb,3,0); /* Reserved */
 
183
 
 
184
        put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
 
185
 
 
186
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 
187
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 
188
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 
189
        put_bits(&s->pb,2,0); /* Reserved */
 
190
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 
191
 
 
192
        /* This should be here if PLUSPTYPE */
 
193
        put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 
194
 
 
195
        if (format == 8) {
 
196
            /* Custom Picture Format (CPFMT) */
 
197
            s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
 
198
 
 
199
            put_bits(&s->pb,4,s->aspect_ratio_info);
 
200
            put_bits(&s->pb,9,(s->width >> 2) - 1);
 
201
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 
202
            put_bits(&s->pb,9,(s->height >> 2));
 
203
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
 
204
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
 
205
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
 
206
            }
 
207
        }
 
208
        if(s->custom_pcf){
 
209
            if(ufep){
 
210
                put_bits(&s->pb, 1, best_clock_code);
 
211
                put_bits(&s->pb, 7, best_divisor);
 
212
            }
 
213
            put_sbits(&s->pb, 2, temp_ref>>8);
 
214
        }
 
215
 
 
216
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 
217
        if (s->umvplus)
 
218
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 
219
//FIXME check actual requested range
 
220
            put_bits(&s->pb,2,1); /* unlimited */
 
221
        if(s->h263_slice_structured)
 
222
            put_bits(&s->pb,2,0); /* no weird submodes */
 
223
 
 
224
        put_bits(&s->pb, 5, s->qscale);
 
225
    }
 
226
 
 
227
    put_bits(&s->pb, 1, 0);     /* no PEI */
 
228
 
 
229
    if(s->h263_slice_structured){
 
230
        put_bits(&s->pb, 1, 1);
 
231
 
 
232
        assert(s->mb_x == 0 && s->mb_y == 0);
 
233
        ff_h263_encode_mba(s);
 
234
 
 
235
        put_bits(&s->pb, 1, 1);
 
236
    }
 
237
 
 
238
    if(s->h263_aic){
 
239
         s->y_dc_scale_table=
 
240
         s->c_dc_scale_table= ff_aic_dc_scale_table;
 
241
    }else{
 
242
        s->y_dc_scale_table=
 
243
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
244
    }
 
245
}
 
246
 
 
247
/**
 
248
 * Encode a group of blocks header.
 
249
 */
 
250
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
 
251
{
 
252
    put_bits(&s->pb, 17, 1); /* GBSC */
 
253
 
 
254
    if(s->h263_slice_structured){
 
255
        put_bits(&s->pb, 1, 1);
 
256
 
 
257
        ff_h263_encode_mba(s);
 
258
 
 
259
        if(s->mb_num > 1583)
 
260
            put_bits(&s->pb, 1, 1);
 
261
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 
262
        put_bits(&s->pb, 1, 1);
 
263
        put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
 
264
    }else{
 
265
        int gob_number= mb_line / s->gob_index;
 
266
 
 
267
        put_bits(&s->pb, 5, gob_number); /* GN */
 
268
        put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
 
269
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 
270
    }
 
271
}
 
272
 
 
273
/**
 
274
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 
275
 */
 
276
void ff_clean_h263_qscales(MpegEncContext *s){
 
277
    int i;
 
278
    int8_t * const qscale_table= s->current_picture.qscale_table;
 
279
 
 
280
    ff_init_qscale_tab(s);
 
281
 
 
282
    for(i=1; i<s->mb_num; i++){
 
283
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
 
284
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
 
285
    }
 
286
    for(i=s->mb_num-2; i>=0; i--){
 
287
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
 
288
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
 
289
    }
 
290
 
 
291
    if(s->codec_id != CODEC_ID_H263P){
 
292
        for(i=1; i<s->mb_num; i++){
 
293
            int mb_xy= s->mb_index2xy[i];
 
294
 
 
295
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
 
296
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
 
297
            }
 
298
        }
 
299
    }
 
300
}
 
301
 
 
302
static const int dquant_code[5]= {1,0,9,2,3};
 
303
 
 
304
/**
 
305
 * encodes a 8x8 block.
 
306
 * @param block the 8x8 block
 
307
 * @param n block index (0-3 are luma, 4-5 are chroma)
 
308
 */
 
309
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 
310
{
 
311
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
 
312
    RLTable *rl;
 
313
 
 
314
    rl = &ff_h263_rl_inter;
 
315
    if (s->mb_intra && !s->h263_aic) {
 
316
        /* DC coef */
 
317
        level = block[0];
 
318
        /* 255 cannot be represented, so we clamp */
 
319
        if (level > 254) {
 
320
            level = 254;
 
321
            block[0] = 254;
 
322
        }
 
323
        /* 0 cannot be represented also */
 
324
        else if (level < 1) {
 
325
            level = 1;
 
326
            block[0] = 1;
 
327
        }
 
328
        if (level == 128) //FIXME check rv10
 
329
            put_bits(&s->pb, 8, 0xff);
 
330
        else
 
331
            put_bits(&s->pb, 8, level);
 
332
        i = 1;
 
333
    } else {
 
334
        i = 0;
 
335
        if (s->h263_aic && s->mb_intra)
 
336
            rl = &rl_intra_aic;
 
337
 
 
338
        if(s->alt_inter_vlc && !s->mb_intra){
 
339
            int aic_vlc_bits=0;
 
340
            int inter_vlc_bits=0;
 
341
            int wrong_pos=-1;
 
342
            int aic_code;
 
343
 
 
344
            last_index = s->block_last_index[n];
 
345
            last_non_zero = i - 1;
 
346
            for (; i <= last_index; i++) {
 
347
                j = s->intra_scantable.permutated[i];
 
348
                level = block[j];
 
349
                if (level) {
 
350
                    run = i - last_non_zero - 1;
 
351
                    last = (i == last_index);
 
352
 
 
353
                    if(level<0) level= -level;
 
354
 
 
355
                    code = get_rl_index(rl, last, run, level);
 
356
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
 
357
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
 
358
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
 
359
 
 
360
                    if (code == rl->n) {
 
361
                        inter_vlc_bits += 1+6+8-1;
 
362
                    }
 
363
                    if (aic_code == rl_intra_aic.n) {
 
364
                        aic_vlc_bits += 1+6+8-1;
 
365
                        wrong_pos += run + 1;
 
366
                    }else
 
367
                        wrong_pos += wrong_run[aic_code];
 
368
                    last_non_zero = i;
 
369
                }
 
370
            }
 
371
            i = 0;
 
372
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
 
373
                rl = &rl_intra_aic;
 
374
        }
 
375
    }
 
376
 
 
377
    /* AC coefs */
 
378
    last_index = s->block_last_index[n];
 
379
    last_non_zero = i - 1;
 
380
    for (; i <= last_index; i++) {
 
381
        j = s->intra_scantable.permutated[i];
 
382
        level = block[j];
 
383
        if (level) {
 
384
            run = i - last_non_zero - 1;
 
385
            last = (i == last_index);
 
386
            sign = 0;
 
387
            slevel = level;
 
388
            if (level < 0) {
 
389
                sign = 1;
 
390
                level = -level;
 
391
            }
 
392
            code = get_rl_index(rl, last, run, level);
 
393
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
394
            if (code == rl->n) {
 
395
              if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
 
396
                put_bits(&s->pb, 1, last);
 
397
                put_bits(&s->pb, 6, run);
 
398
 
 
399
                assert(slevel != 0);
 
400
 
 
401
                if(level < 128)
 
402
                    put_sbits(&s->pb, 8, slevel);
 
403
                else{
 
404
                    put_bits(&s->pb, 8, 128);
 
405
                    put_sbits(&s->pb, 5, slevel);
 
406
                    put_sbits(&s->pb, 6, slevel>>5);
 
407
                }
 
408
              }else{
 
409
                    ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
 
410
              }
 
411
            } else {
 
412
                put_bits(&s->pb, 1, sign);
 
413
            }
 
414
            last_non_zero = i;
 
415
        }
 
416
    }
 
417
}
 
418
 
 
419
/* Encode MV differences on H.263+ with Unrestricted MV mode */
 
420
static void h263p_encode_umotion(MpegEncContext * s, int val)
 
421
{
 
422
    short sval = 0;
 
423
    short i = 0;
 
424
    short n_bits = 0;
 
425
    short temp_val;
 
426
    int code = 0;
 
427
    int tcode;
 
428
 
 
429
    if ( val == 0)
 
430
        put_bits(&s->pb, 1, 1);
 
431
    else if (val == 1)
 
432
        put_bits(&s->pb, 3, 0);
 
433
    else if (val == -1)
 
434
        put_bits(&s->pb, 3, 2);
 
435
    else {
 
436
 
 
437
        sval = ((val < 0) ? (short)(-val):(short)val);
 
438
        temp_val = sval;
 
439
 
 
440
        while (temp_val != 0) {
 
441
            temp_val = temp_val >> 1;
 
442
            n_bits++;
 
443
        }
 
444
 
 
445
        i = n_bits - 1;
 
446
        while (i > 0) {
 
447
            tcode = (sval & (1 << (i-1))) >> (i-1);
 
448
            tcode = (tcode << 1) | 1;
 
449
            code = (code << 2) | tcode;
 
450
            i--;
 
451
        }
 
452
        code = ((code << 1) | (val < 0)) << 1;
 
453
        put_bits(&s->pb, (2*n_bits)+1, code);
 
454
    }
 
455
}
 
456
 
 
457
void h263_encode_mb(MpegEncContext * s,
 
458
                    DCTELEM block[6][64],
 
459
                    int motion_x, int motion_y)
 
460
{
 
461
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
 
462
    int16_t pred_dc;
 
463
    int16_t rec_intradc[6];
 
464
    int16_t *dc_ptr[6];
 
465
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
 
466
 
 
467
    if (!s->mb_intra) {
 
468
        /* compute cbp */
 
469
        cbp= get_p_cbp(s, block, motion_x, motion_y);
 
470
 
 
471
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
 
472
            /* skip macroblock */
 
473
            put_bits(&s->pb, 1, 1);
 
474
            if(interleaved_stats){
 
475
                s->misc_bits++;
 
476
                s->last_bits++;
 
477
            }
 
478
            s->skip_count++;
 
479
 
 
480
            return;
 
481
        }
 
482
        put_bits(&s->pb, 1, 0);         /* mb coded */
 
483
 
 
484
        cbpc = cbp & 3;
 
485
        cbpy = cbp >> 2;
 
486
        if(s->alt_inter_vlc==0 || cbpc!=3)
 
487
            cbpy ^= 0xF;
 
488
        if(s->dquant) cbpc+= 8;
 
489
        if(s->mv_type==MV_TYPE_16X16){
 
490
            put_bits(&s->pb,
 
491
                    ff_h263_inter_MCBPC_bits[cbpc],
 
492
                    ff_h263_inter_MCBPC_code[cbpc]);
 
493
 
 
494
            put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 
495
            if(s->dquant)
 
496
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 
497
 
 
498
            if(interleaved_stats){
 
499
                s->misc_bits+= get_bits_diff(s);
 
500
            }
 
501
 
 
502
            /* motion vectors: 16x16 mode */
 
503
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
504
 
 
505
            if (!s->umvplus) {
 
506
                ff_h263_encode_motion_vector(s, motion_x - pred_x,
 
507
                                                motion_y - pred_y, 1);
 
508
            }
 
509
            else {
 
510
                h263p_encode_umotion(s, motion_x - pred_x);
 
511
                h263p_encode_umotion(s, motion_y - pred_y);
 
512
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 
513
                    /* To prevent Start Code emulation */
 
514
                    put_bits(&s->pb,1,1);
 
515
            }
 
516
        }else{
 
517
            put_bits(&s->pb,
 
518
                    ff_h263_inter_MCBPC_bits[cbpc+16],
 
519
                    ff_h263_inter_MCBPC_code[cbpc+16]);
 
520
            put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 
521
            if(s->dquant)
 
522
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 
523
 
 
524
            if(interleaved_stats){
 
525
                s->misc_bits+= get_bits_diff(s);
 
526
            }
 
527
 
 
528
            for(i=0; i<4; i++){
 
529
                /* motion vectors: 8x8 mode*/
 
530
                h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 
531
 
 
532
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
 
533
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
 
534
                if (!s->umvplus) {
 
535
                    ff_h263_encode_motion_vector(s, motion_x - pred_x,
 
536
                                                    motion_y - pred_y, 1);
 
537
                }
 
538
                else {
 
539
                    h263p_encode_umotion(s, motion_x - pred_x);
 
540
                    h263p_encode_umotion(s, motion_y - pred_y);
 
541
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 
542
                        /* To prevent Start Code emulation */
 
543
                        put_bits(&s->pb,1,1);
 
544
                }
 
545
            }
 
546
        }
 
547
 
 
548
        if(interleaved_stats){
 
549
            s->mv_bits+= get_bits_diff(s);
 
550
        }
 
551
    } else {
 
552
        assert(s->mb_intra);
 
553
 
 
554
        cbp = 0;
 
555
        if (s->h263_aic) {
 
556
            /* Predict DC */
 
557
            for(i=0; i<6; i++) {
 
558
                int16_t level = block[i][0];
 
559
                int scale;
 
560
 
 
561
                if(i<4) scale= s->y_dc_scale;
 
562
                else    scale= s->c_dc_scale;
 
563
 
 
564
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
 
565
                level -= pred_dc;
 
566
                /* Quant */
 
567
                if (level >= 0)
 
568
                    level = (level + (scale>>1))/scale;
 
569
                else
 
570
                    level = (level - (scale>>1))/scale;
 
571
 
 
572
                /* AIC can change CBP */
 
573
                if (level == 0 && s->block_last_index[i] == 0)
 
574
                    s->block_last_index[i] = -1;
 
575
 
 
576
                if(!s->modified_quant){
 
577
                    if (level < -127)
 
578
                        level = -127;
 
579
                    else if (level > 127)
 
580
                        level = 127;
 
581
                }
 
582
 
 
583
                block[i][0] = level;
 
584
                /* Reconstruction */
 
585
                rec_intradc[i] = scale*level + pred_dc;
 
586
                /* Oddify */
 
587
                rec_intradc[i] |= 1;
 
588
                //if ((rec_intradc[i] % 2) == 0)
 
589
                //    rec_intradc[i]++;
 
590
                /* Clipping */
 
591
                if (rec_intradc[i] < 0)
 
592
                    rec_intradc[i] = 0;
 
593
                else if (rec_intradc[i] > 2047)
 
594
                    rec_intradc[i] = 2047;
 
595
 
 
596
                /* Update AC/DC tables */
 
597
                *dc_ptr[i] = rec_intradc[i];
 
598
                if (s->block_last_index[i] >= 0)
 
599
                    cbp |= 1 << (5 - i);
 
600
            }
 
601
        }else{
 
602
            for(i=0; i<6; i++) {
 
603
                /* compute cbp */
 
604
                if (s->block_last_index[i] >= 1)
 
605
                    cbp |= 1 << (5 - i);
 
606
            }
 
607
        }
 
608
 
 
609
        cbpc = cbp & 3;
 
610
        if (s->pict_type == FF_I_TYPE) {
 
611
            if(s->dquant) cbpc+=4;
 
612
            put_bits(&s->pb,
 
613
                ff_h263_intra_MCBPC_bits[cbpc],
 
614
                ff_h263_intra_MCBPC_code[cbpc]);
 
615
        } else {
 
616
            if(s->dquant) cbpc+=8;
 
617
            put_bits(&s->pb, 1, 0);     /* mb coded */
 
618
            put_bits(&s->pb,
 
619
                ff_h263_inter_MCBPC_bits[cbpc + 4],
 
620
                ff_h263_inter_MCBPC_code[cbpc + 4]);
 
621
        }
 
622
        if (s->h263_aic) {
 
623
            /* XXX: currently, we do not try to use ac prediction */
 
624
            put_bits(&s->pb, 1, 0);     /* no AC prediction */
 
625
        }
 
626
        cbpy = cbp >> 2;
 
627
        put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 
628
        if(s->dquant)
 
629
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 
630
 
 
631
        if(interleaved_stats){
 
632
            s->misc_bits+= get_bits_diff(s);
 
633
        }
 
634
    }
 
635
 
 
636
    for(i=0; i<6; i++) {
 
637
        /* encode each block */
 
638
        h263_encode_block(s, block[i], i);
 
639
 
 
640
        /* Update INTRADC for decoding */
 
641
        if (s->h263_aic && s->mb_intra) {
 
642
            block[i][0] = rec_intradc[i];
 
643
 
 
644
        }
 
645
    }
 
646
 
 
647
    if(interleaved_stats){
 
648
        if (!s->mb_intra) {
 
649
            s->p_tex_bits+= get_bits_diff(s);
 
650
            s->f_count++;
 
651
        }else{
 
652
            s->i_tex_bits+= get_bits_diff(s);
 
653
            s->i_count++;
 
654
        }
 
655
    }
 
656
}
 
657
 
 
658
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
 
659
{
 
660
    int range, l, bit_size, sign, code, bits;
 
661
 
 
662
    if (val == 0) {
 
663
        /* zero vector */
 
664
        code = 0;
 
665
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 
666
    } else {
 
667
        bit_size = f_code - 1;
 
668
        range = 1 << bit_size;
 
669
        /* modulo encoding */
 
670
        l= INT_BIT - 6 - bit_size;
 
671
        val = (val<<l)>>l;
 
672
        sign = val>>31;
 
673
        val= (val^sign)-sign;
 
674
        sign&=1;
 
675
 
 
676
        val--;
 
677
        code = (val >> bit_size) + 1;
 
678
        bits = val & (range - 1);
 
679
 
 
680
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 
681
        if (bit_size > 0) {
 
682
            put_bits(&s->pb, bit_size, bits);
 
683
        }
 
684
    }
 
685
}
 
686
 
 
687
static void init_mv_penalty_and_fcode(MpegEncContext *s)
 
688
{
 
689
    int f_code;
 
690
    int mv;
 
691
 
 
692
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
 
693
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 
694
            int len;
 
695
 
 
696
            if(mv==0) len= mvtab[0][1];
 
697
            else{
 
698
                int val, bit_size, code;
 
699
 
 
700
                bit_size = f_code - 1;
 
701
 
 
702
                val=mv;
 
703
                if (val < 0)
 
704
                    val = -val;
 
705
                val--;
 
706
                code = (val >> bit_size) + 1;
 
707
                if(code<33){
 
708
                    len= mvtab[code][1] + 1 + bit_size;
 
709
                }else{
 
710
                    len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
 
711
                }
 
712
            }
 
713
 
 
714
            mv_penalty[f_code][mv+MAX_MV]= len;
 
715
        }
 
716
    }
 
717
 
 
718
    for(f_code=MAX_FCODE; f_code>0; f_code--){
 
719
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
 
720
            fcode_tab[mv+MAX_MV]= f_code;
 
721
        }
 
722
    }
 
723
 
 
724
    for(mv=0; mv<MAX_MV*2+1; mv++){
 
725
        umv_fcode_tab[mv]= 1;
 
726
    }
 
727
}
 
728
 
 
729
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
 
730
    int slevel, run, last;
 
731
 
 
732
    assert(MAX_LEVEL >= 64);
 
733
    assert(MAX_RUN   >= 63);
 
734
 
 
735
    for(slevel=-64; slevel<64; slevel++){
 
736
        if(slevel==0) continue;
 
737
        for(run=0; run<64; run++){
 
738
            for(last=0; last<=1; last++){
 
739
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
 
740
                int level= slevel < 0 ? -slevel : slevel;
 
741
                int sign= slevel < 0 ? 1 : 0;
 
742
                int bits, len, code;
 
743
 
 
744
                len_tab[index]= 100;
 
745
 
 
746
                /* ESC0 */
 
747
                code= get_rl_index(rl, last, run, level);
 
748
                bits= rl->table_vlc[code][0];
 
749
                len=  rl->table_vlc[code][1];
 
750
                bits=bits*2+sign; len++;
 
751
 
 
752
                if(code!=rl->n && len < len_tab[index]){
 
753
                    if(bits_tab) bits_tab[index]= bits;
 
754
                    len_tab [index]= len;
 
755
                }
 
756
                /* ESC */
 
757
                bits= rl->table_vlc[rl->n][0];
 
758
                len = rl->table_vlc[rl->n][1];
 
759
                bits=bits*2+last; len++;
 
760
                bits=bits*64+run; len+=6;
 
761
                bits=bits*256+(level&0xff); len+=8;
 
762
 
 
763
                if(len < len_tab[index]){
 
764
                    if(bits_tab) bits_tab[index]= bits;
 
765
                    len_tab [index]= len;
 
766
                }
 
767
            }
 
768
        }
 
769
    }
 
770
}
 
771
 
 
772
void h263_encode_init(MpegEncContext *s)
 
773
{
 
774
    static int done = 0;
 
775
 
 
776
    if (!done) {
 
777
        done = 1;
 
778
 
 
779
        init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
 
780
        init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);
 
781
 
 
782
        init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
 
783
        init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
 
784
 
 
785
        init_mv_penalty_and_fcode(s);
 
786
    }
 
787
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
 
788
 
 
789
    s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
 
790
    s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
 
791
    if(s->h263_aic){
 
792
        s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
 
793
        s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
 
794
    }
 
795
    s->ac_esc_length= 7+1+6+8;
 
796
 
 
797
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
 
798
    switch(s->codec_id){
 
799
    case CODEC_ID_MPEG4:
 
800
        s->fcode_tab= fcode_tab;
 
801
        break;
 
802
    case CODEC_ID_H263P:
 
803
        if(s->umvplus)
 
804
            s->fcode_tab= umv_fcode_tab;
 
805
        if(s->modified_quant){
 
806
            s->min_qcoeff= -2047;
 
807
            s->max_qcoeff=  2047;
 
808
        }else{
 
809
            s->min_qcoeff= -127;
 
810
            s->max_qcoeff=  127;
 
811
        }
 
812
        break;
 
813
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
 
814
    case CODEC_ID_FLV1:
 
815
        if (s->h263_flv > 1) {
 
816
            s->min_qcoeff= -1023;
 
817
            s->max_qcoeff=  1023;
 
818
        } else {
 
819
            s->min_qcoeff= -127;
 
820
            s->max_qcoeff=  127;
 
821
        }
 
822
        s->y_dc_scale_table=
 
823
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
824
        break;
 
825
    default: //nothing needed - default table already set in mpegvideo.c
 
826
        s->min_qcoeff= -127;
 
827
        s->max_qcoeff=  127;
 
828
        s->y_dc_scale_table=
 
829
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
830
    }
 
831
}
 
832
 
 
833
void ff_h263_encode_mba(MpegEncContext *s)
 
834
{
 
835
    int i, mb_pos;
 
836
 
 
837
    for(i=0; i<6; i++){
 
838
        if(s->mb_num-1 <= ff_mba_max[i]) break;
 
839
    }
 
840
    mb_pos= s->mb_x + s->mb_width*s->mb_y;
 
841
    put_bits(&s->pb, ff_mba_length[i], mb_pos);
 
842
}