Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ 399cec2f

History | View | Annotate | Download (205 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 6dbd39fe Juanjo
 * H263+ support.
5 de6d9b64 Fabrice Bellard
 * Copyright (c) 2001 Juan J. Sierralta P.
6 8f2ab833 Michael Niedermayer
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7 de6d9b64 Fabrice Bellard
 *
8 ff4ec49e Fabrice Bellard
 * This library 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 of the License, or (at your option) any later version.
12 de6d9b64 Fabrice Bellard
 *
13 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
14 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17 de6d9b64 Fabrice Bellard
 *
18 ff4ec49e Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with this library; if not, write to the Free Software
20
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21 45870f57 Michael Niedermayer
 *
22 66370d3f Michael Niedermayer
 * ac prediction encoding, b-frame support, error resilience, optimizations,
23
 * qpel decoding, gmc decoding, interlaced decoding, 
24
 * by Michael Niedermayer <michaelni@gmx.at>
25 de6d9b64 Fabrice Bellard
 */
26 2ba8f6b8 Michael Niedermayer
27
/**
28
 * @file h263.c
29 983e3246 Michael Niedermayer
 * h263/mpeg4 codec.
30 2ba8f6b8 Michael Niedermayer
 */
31 1e209222 Juanjo
 
32
//#define DEBUG
33 f2f6134b Michael Niedermayer
#include <limits.h>
34
35 de6d9b64 Fabrice Bellard
#include "common.h"
36
#include "dsputil.h"
37
#include "avcodec.h"
38
#include "mpegvideo.h"
39
#include "h263data.h"
40
#include "mpeg4data.h"
41
42 c5d309f2 Michael Niedermayer
//#undef NDEBUG
43
//#include <assert.h>
44
45 edcf9890 Michael Niedermayer
#define INTRA_MCBPC_VLC_BITS 6
46 7af75e6c Michael Niedermayer
#define INTER_MCBPC_VLC_BITS 7
47 edcf9890 Michael Niedermayer
#define CBPY_VLC_BITS 6
48
#define MV_VLC_BITS 9
49
#define DC_VLC_BITS 9
50
#define SPRITE_TRAJ_VLC_BITS 6
51
#define MB_TYPE_B_VLC_BITS 4
52
#define TEX_VLC_BITS 9
53 b40cd4e0 Michael Niedermayer
#define H263_MBTYPE_B_VLC_BITS 6
54
#define CBPC_B_VLC_BITS 3
55 edcf9890 Michael Niedermayer
56 bbed9259 Michael Niedermayer
#ifdef CONFIG_ENCODERS
57 de6d9b64 Fabrice Bellard
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
58 d4f5d74a Garrick Meeker
                              int n);
59 9dbcbd92 Michael Niedermayer
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
60 6dbd39fe Juanjo
static void h263p_encode_umotion(MpegEncContext * s, int val);
61 3db48188 Michael Niedermayer
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
62 d4f5d74a Garrick Meeker
                               int n, int dc, uint8_t *scan_table, 
63 92073d01 Michael Niedermayer
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
64 bbed9259 Michael Niedermayer
#endif
65
66 6f91bcd1 Michael Niedermayer
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
67 6dbd39fe Juanjo
static int h263p_decode_umotion(MpegEncContext * s, int pred);
68 de6d9b64 Fabrice Bellard
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
69
                             int n, int coded);
70 92073d01 Michael Niedermayer
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
71
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
72 a4e8b587 Michael Niedermayer
                              int n, int coded, int intra, int rvlc);
73 0c1a9eda Zdenek Kabelac
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
74 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
75 22ddd60b Michael Niedermayer
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
76
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
77 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
78 49092244 Michael Niedermayer
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
79 0c1a9eda Zdenek Kabelac
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
80 4d2858de Michael Niedermayer
81 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
82 0c1a9eda Zdenek Kabelac
static uint8_t uni_DCtab_lum_len[512];
83
static uint8_t uni_DCtab_chrom_len[512];
84
static uint16_t uni_DCtab_lum_bits[512];
85
static uint16_t uni_DCtab_chrom_bits[512];
86 bbed9259 Michael Niedermayer
87 30952237 Michael Niedermayer
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
88 0c1a9eda Zdenek Kabelac
static uint8_t fcode_tab[MAX_MV*2+1];
89
static uint8_t umv_fcode_tab[MAX_MV*2+1];
90 45870f57 Michael Niedermayer
91 477ab036 Michael Niedermayer
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
92
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
93
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
94
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
95
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
96 3db48188 Michael Niedermayer
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
97 477ab036 Michael Niedermayer
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
98 3db48188 Michael Niedermayer
99
/* mpeg4
100
inter
101
max level: 24/6
102
max run: 53/63
103

104
intra
105
max level: 53/16
106
max run: 29/41
107
*/
108 bbed9259 Michael Niedermayer
#endif
109
110 6d71b382 Michael Niedermayer
#if 0 //3IV1 is quite rare and tis slows things down a tiny bit
111
#define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
112
#else 
113
#define IS_3IV1 0
114
#endif
115 2a164b25 Michael Niedermayer
116 de6d9b64 Fabrice Bellard
int h263_get_picture_format(int width, int height)
117
{
118
    int format;
119
120
    if (width == 128 && height == 96)
121 1e209222 Juanjo
        format = 1;
122 de6d9b64 Fabrice Bellard
    else if (width == 176 && height == 144)
123 1e209222 Juanjo
        format = 2;
124 de6d9b64 Fabrice Bellard
    else if (width == 352 && height == 288)
125 1e209222 Juanjo
        format = 3;
126 de6d9b64 Fabrice Bellard
    else if (width == 704 && height == 576)
127 1e209222 Juanjo
        format = 4;
128 de6d9b64 Fabrice Bellard
    else if (width == 1408 && height == 1152)
129 1e209222 Juanjo
        format = 5;
130 de6d9b64 Fabrice Bellard
    else
131
        format = 7;
132
    return format;
133
}
134
135 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
136
137 5ff85f1d Michael Niedermayer
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
138 58b0b0dd Michael Niedermayer
    int i;
139
140 5ff85f1d Michael Niedermayer
    if(aspect.num==0) aspect= (AVRational){1,1};
141 58b0b0dd Michael Niedermayer
142
    for(i=1; i<6; i++){
143 5ff85f1d Michael Niedermayer
        if(av_cmp_q(pixel_aspect[i], aspect) == 0){
144 58b0b0dd Michael Niedermayer
            s->aspect_ratio_info=i;
145
            return;
146
        }
147
    }
148 5d3cea3a Michael Niedermayer
    
149 58b0b0dd Michael Niedermayer
    s->aspect_ratio_info= FF_ASPECT_EXTENDED;
150 5d3cea3a Michael Niedermayer
}
151
152 44a2950f Michael Niedermayer
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
153 de6d9b64 Fabrice Bellard
{
154 44a2950f Michael Niedermayer
      int format;
155 de6d9b64 Fabrice Bellard
156 44a2950f Michael Niedermayer
      align_put_bits(&s->pb);
157 81401c1f Juanjo
158 d4f5d74a Garrick Meeker
      put_bits(&s->pb, 17, 1);
159
      put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
160
      put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
161
                           s->avctx->frame_rate) & 0xff); /* TemporalReference */
162
      if (s->width == 352 && s->height == 288)
163
        format = 2;
164
      else if (s->width == 176 && s->height == 144)
165
        format = 3;
166
      else if (s->width == 128 && s->height == 96)
167
        format = 4;
168
      else if (s->width == 320 && s->height == 240)
169
        format = 5;
170
      else if (s->width == 160 && s->height == 120)
171
        format = 6;
172
      else if (s->width <= 255 && s->height <= 255)
173
        format = 0; /* use 1 byte width & height */
174
      else
175
        format = 1; /* use 2 bytes width & height */
176
      put_bits(&s->pb, 3, format); /* PictureSize */
177
      if (format == 0) {
178
        put_bits(&s->pb, 8, s->width);
179
        put_bits(&s->pb, 8, s->height);
180
      } else if (format == 1) {
181
        put_bits(&s->pb, 16, s->width);
182
        put_bits(&s->pb, 16, s->height);
183
      }
184
      put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
185 f5ea4461 Michael Niedermayer
      put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
186 d4f5d74a Garrick Meeker
      put_bits(&s->pb, 5, s->qscale); /* Quantizer */
187
      put_bits(&s->pb, 1, 0); /* ExtraInformation */
188
189
      if(s->h263_aic){
190
        s->y_dc_scale_table= 
191 68b94c35 Michael Niedermayer
          s->c_dc_scale_table= ff_aic_dc_scale_table;
192 d4f5d74a Garrick Meeker
      }else{
193
        s->y_dc_scale_table=
194
          s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
195
      }
196 44a2950f Michael Niedermayer
}
197
198
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
199
{
200
    int format;
201
202
    align_put_bits(&s->pb);
203 d4f5d74a Garrick Meeker
204 81401c1f Juanjo
    /* Update the pointer to last GOB */
205 17592475 Michael Niedermayer
    s->ptr_lastgob = pbBufPtr(&s->pb);
206 81401c1f Juanjo
    put_bits(&s->pb, 22, 0x20); /* PSC */
207 14bea432 Michael Niedermayer
    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / 
208
                         s->avctx->frame_rate) & 0xff);
209 de6d9b64 Fabrice Bellard
210
    put_bits(&s->pb, 1, 1);        /* marker */
211
    put_bits(&s->pb, 1, 0);        /* h263 id */
212
    put_bits(&s->pb, 1, 0);        /* split screen off */
213
    put_bits(&s->pb, 1, 0);        /* camera  off */
214
    put_bits(&s->pb, 1, 0);        /* freeze picture release off */
215 6dbd39fe Juanjo
    
216
    format = h263_get_picture_format(s->width, s->height);
217 de6d9b64 Fabrice Bellard
    if (!s->h263_plus) {
218
        /* H.263v1 */
219
        put_bits(&s->pb, 3, format);
220
        put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
221
        /* By now UMV IS DISABLED ON H.263v1, since the restrictions
222
        of H.263v1 UMV implies to check the predicted MV after
223
        calculation of the current MB to see if we're on the limits */
224
        put_bits(&s->pb, 1, 0);        /* unrestricted motion vector: off */
225
        put_bits(&s->pb, 1, 0);        /* SAC: off */
226 f7190f73 Michael Niedermayer
        put_bits(&s->pb, 1, s->obmc);        /* advanced prediction mode */
227 de6d9b64 Fabrice Bellard
        put_bits(&s->pb, 1, 0);        /* not PB frame */
228
        put_bits(&s->pb, 5, s->qscale);
229
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
230
    } else {
231
        /* H.263v2 */
232
        /* H.263 Plus PTYPE */
233
        put_bits(&s->pb, 3, 7);
234
        put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
235 6dbd39fe Juanjo
        if (format == 7)
236
            put_bits(&s->pb,3,6); /* Custom Source Format */
237
        else
238
            put_bits(&s->pb, 3, format);
239
            
240 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,1,0); /* Custom PCF: off */
241 ba58dabc Michael Niedermayer
        put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
242 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,1,0); /* SAC: off */
243 f7190f73 Michael Niedermayer
        put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
244 ef5b1b5a Juanjo
        put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
245 332f9ac4 Michael Niedermayer
        put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
246 ba58dabc Michael Niedermayer
        put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
247 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
248
        put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
249 dba019da Michael Niedermayer
        put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
250 332f9ac4 Michael Niedermayer
        put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
251 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
252
        put_bits(&s->pb,3,0); /* Reserved */
253
                
254
        put_bits(&s->pb, 3, s->pict_type == P_TYPE);
255
                
256
        put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
257
        put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
258 ef5b1b5a Juanjo
        put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
259 de6d9b64 Fabrice Bellard
        put_bits(&s->pb,2,0); /* Reserved */
260
        put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
261
                
262
        /* This should be here if PLUSPTYPE */
263
        put_bits(&s->pb, 1, 0);        /* Continuous Presence Multipoint mode: off */
264
                
265 6dbd39fe Juanjo
                if (format == 7) {
266
            /* Custom Picture Format (CPFMT) */
267 5ff85f1d Michael Niedermayer
            aspect_to_info(s, s->avctx->sample_aspect_ratio);
268 5d3cea3a Michael Niedermayer
269
            put_bits(&s->pb,4,s->aspect_ratio_info);
270 6dbd39fe Juanjo
            put_bits(&s->pb,9,(s->width >> 2) - 1);
271
            put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
272
            put_bits(&s->pb,9,(s->height >> 2));
273 5ff85f1d Michael Niedermayer
            if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
274
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
275
                put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
276 050fe8ba Alex Beregszaszi
            }
277 6dbd39fe Juanjo
        }
278
        
279 de6d9b64 Fabrice Bellard
        /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
280 544286b3 Juanjo
        if (s->umvplus)
281 e51d6d27 Michael Niedermayer
//            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
282 332f9ac4 Michael Niedermayer
//FIXME check actual requested range
283 e51d6d27 Michael Niedermayer
            put_bits(&s->pb,2,1); /* unlimited */
284 ba58dabc Michael Niedermayer
        if(s->h263_slice_structured)
285
            put_bits(&s->pb,2,0); /* no weird submodes */
286 e51d6d27 Michael Niedermayer
287 de6d9b64 Fabrice Bellard
        put_bits(&s->pb, 5, s->qscale);
288
    }
289
290
    put_bits(&s->pb, 1, 0);        /* no PEI */
291 8f8402e4 Michael Niedermayer
292 0ed714a7 Michael Niedermayer
    if(s->h263_slice_structured){
293
        put_bits(&s->pb, 1, 1);
294
        
295
        assert(s->mb_x == 0 && s->mb_y == 0);
296
        ff_h263_encode_mba(s);
297
298
        put_bits(&s->pb, 1, 1);
299
    }
300
301 8f8402e4 Michael Niedermayer
    if(s->h263_aic){
302
         s->y_dc_scale_table= 
303 68b94c35 Michael Niedermayer
         s->c_dc_scale_table= ff_aic_dc_scale_table;
304 8f8402e4 Michael Niedermayer
    }else{
305
        s->y_dc_scale_table=
306
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
307
    }
308 de6d9b64 Fabrice Bellard
}
309
310 945eeee1 Michael Niedermayer
/**
311
 * Encodes a group of blocks header.
312
 */
313 ba58dabc Michael Niedermayer
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
314 644d98a4 Juanjo
{
315 ba58dabc Michael Niedermayer
    put_bits(&s->pb, 17, 1); /* GBSC */
316
317
    if(s->h263_slice_structured){
318
        put_bits(&s->pb, 1, 1);
319
320
        ff_h263_encode_mba(s);
321
322
        if(s->mb_num > 1583)
323
            put_bits(&s->pb, 1, 1);
324
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
325
        put_bits(&s->pb, 1, 1);
326
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
327
    }else{
328
        int gob_number= mb_line / s->gob_index;
329
330
        put_bits(&s->pb, 5, gob_number); /* GN */
331
        put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
332
        put_bits(&s->pb, 5, s->qscale); /* GQUANT */
333
    }
334 644d98a4 Juanjo
}
335 d6231b9e Michael Niedermayer
336 8d8c0294 Michael Niedermayer
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
337
    int last=0;
338
    int j;
339
    int rate=0;
340
341
    for(j=1; j<=block_last_index; j++){
342
        const int index= scantable[j];
343
        int level= block[index];
344
        if(level){
345
            level+= 64;
346
            if((level&(~127)) == 0){
347
                if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
348
                else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
349
            }else
350
                rate += s->ac_esc_length;
351
            level-= 64;
352
353
            last= j;
354
        }
355
    }
356
    
357
    return rate;
358
}
359
360
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
361 d6231b9e Michael Niedermayer
{
362 8d8c0294 Michael Niedermayer
    int score= 0;
363 d6231b9e Michael Niedermayer
    int i, n;
364 1e491e29 Michael Niedermayer
    int8_t * const qscale_table= s->current_picture.qscale_table;
365 d6231b9e Michael Niedermayer
366 8d8c0294 Michael Niedermayer
    memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
367
    
368 d6231b9e Michael Niedermayer
    for(n=0; n<6; n++){
369 0c1a9eda Zdenek Kabelac
        int16_t *ac_val, *ac_val1;
370 8d8c0294 Michael Niedermayer
        
371
        score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
372 d6231b9e Michael Niedermayer
373 4278e7a6 Michael Niedermayer
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
374 d6231b9e Michael Niedermayer
        ac_val1= ac_val;
375
        if(dir[n]){
376 7bc9090a Michael Niedermayer
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
377 99609036 Michael Niedermayer
            /* top prediction */
378 4278e7a6 Michael Niedermayer
            ac_val-= s->block_wrap[n]*16;
379 1e491e29 Michael Niedermayer
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
380 99609036 Michael Niedermayer
                /* same qscale */
381
                for(i=1; i<8; i++){
382 b0368839 Michael Niedermayer
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
383 8d8c0294 Michael Niedermayer
                    block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
384 b0368839 Michael Niedermayer
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
385 99609036 Michael Niedermayer
                    ac_val1[i+8]= level;
386
                }
387
            }else{
388
                /* different qscale, we must rescale */
389
                for(i=1; i<8; i++){
390 b0368839 Michael Niedermayer
                    const int level= block[n][s->dsp.idct_permutation[i   ]];
391 8d8c0294 Michael Niedermayer
                    block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
392 b0368839 Michael Niedermayer
                    ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
393 99609036 Michael Niedermayer
                    ac_val1[i+8]= level;
394
                }
395 d6231b9e Michael Niedermayer
            }
396 8d8c0294 Michael Niedermayer
            st[n]= s->intra_h_scantable.permutated;
397 d6231b9e Michael Niedermayer
        }else{
398 7bc9090a Michael Niedermayer
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
399 99609036 Michael Niedermayer
            /* left prediction */
400 d6231b9e Michael Niedermayer
            ac_val-= 16;
401 1e491e29 Michael Niedermayer
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
402 99609036 Michael Niedermayer
                /* same qscale */
403
                for(i=1; i<8; i++){
404 b0368839 Michael Niedermayer
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
405 8d8c0294 Michael Niedermayer
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
406 99609036 Michael Niedermayer
                    ac_val1[i  ]= level;
407 b0368839 Michael Niedermayer
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
408 99609036 Michael Niedermayer
                }
409
            }else{
410
                /* different qscale, we must rescale */
411
                for(i=1; i<8; i++){
412 b0368839 Michael Niedermayer
                    const int level= block[n][s->dsp.idct_permutation[i<<3]];
413 8d8c0294 Michael Niedermayer
                    block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
414 99609036 Michael Niedermayer
                    ac_val1[i  ]= level;
415 b0368839 Michael Niedermayer
                    ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
416 99609036 Michael Niedermayer
                }
417 d6231b9e Michael Niedermayer
            }
418 8d8c0294 Michael Niedermayer
            st[n]= s->intra_v_scantable.permutated;
419 d6231b9e Michael Niedermayer
        }
420 8d8c0294 Michael Niedermayer
421
        for(i=63; i>0; i--) //FIXME optimize
422
            if(block[n][ st[n][i] ]) break;
423
        s->block_last_index[n]= i;
424
425
        score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
426 d6231b9e Michael Niedermayer
    }
427
428 8d8c0294 Michael Niedermayer
    return score < 0;
429
}
430
431
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
432
{
433
    int i, n;
434
    memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
435
436
    for(n=0; n<6; n++){
437
        int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
438
439
        st[n]= s->intra_scantable.permutated;
440
        if(dir[n]){
441
            /* top prediction */
442
            for(i=1; i<8; i++){
443
                block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
444
            }
445
        }else{
446
            /* left prediction */
447
            for(i=1; i<8; i++){
448
                block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
449
            }
450
        }
451
    }
452 d6231b9e Michael Niedermayer
}
453
454 4d2858de Michael Niedermayer
/**
455
 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
456
 */
457 9e4c6948 Michael Niedermayer
void ff_clean_h263_qscales(MpegEncContext *s){
458 c5d309f2 Michael Niedermayer
    int i;
459 1e491e29 Michael Niedermayer
    int8_t * const qscale_table= s->current_picture.qscale_table;
460 c5d309f2 Michael Niedermayer
    
461
    for(i=1; i<s->mb_num; i++){
462 7bc9090a Michael Niedermayer
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
463
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
464 c5d309f2 Michael Niedermayer
    }
465
    for(i=s->mb_num-2; i>=0; i--){
466 7bc9090a Michael Niedermayer
        if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
467
            qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
468 c5d309f2 Michael Niedermayer
    }
469 9e4c6948 Michael Niedermayer
}
470
471 4d2858de Michael Niedermayer
/**
472
 * modify mb_type & qscale so that encoding is acually possible in mpeg4
473
 */
474 9e4c6948 Michael Niedermayer
void ff_clean_mpeg4_qscales(MpegEncContext *s){
475
    int i;
476 1e491e29 Michael Niedermayer
    int8_t * const qscale_table= s->current_picture.qscale_table;
477
478 9e4c6948 Michael Niedermayer
    ff_clean_h263_qscales(s);
479 c5d309f2 Michael Niedermayer
    
480
    for(i=1; i<s->mb_num; i++){
481 7bc9090a Michael Niedermayer
        int mb_xy= s->mb_index2xy[i];
482
    
483 bb198e19 Michael Niedermayer
        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
484
            s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
485
            s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
486 c5d309f2 Michael Niedermayer
        }
487
    }
488
489
    if(s->pict_type== B_TYPE){
490
        int odd=0;
491
        /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
492
           for the actual adaptive quantization */
493
        
494
        for(i=0; i<s->mb_num; i++){
495 7bc9090a Michael Niedermayer
            int mb_xy= s->mb_index2xy[i];
496
            odd += qscale_table[mb_xy]&1;
497 c5d309f2 Michael Niedermayer
        }
498
        
499
        if(2*odd > s->mb_num) odd=1;
500
        else                  odd=0;
501
        
502
        for(i=0; i<s->mb_num; i++){
503 7bc9090a Michael Niedermayer
            int mb_xy= s->mb_index2xy[i];
504
            if((qscale_table[mb_xy]&1) != odd)
505
                qscale_table[mb_xy]++;
506
            if(qscale_table[mb_xy] > 31)
507
                qscale_table[mb_xy]= 31;
508 c5d309f2 Michael Niedermayer
        }            
509
    
510
        for(i=1; i<s->mb_num; i++){
511 7bc9090a Michael Niedermayer
            int mb_xy= s->mb_index2xy[i];
512 bb198e19 Michael Niedermayer
            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
513
                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
514
                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
515 c5d309f2 Michael Niedermayer
            }
516
        }
517
    }
518
}
519
520 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
521 7bc9090a Michael Niedermayer
/**
522
 *
523
 * @return the mb_type
524
 */
525
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
526
    const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
527 bb198e19 Michael Niedermayer
    const int colocated_mb_type= s->next_picture.mb_type[mb_index];
528 1457ab52 Michael Niedermayer
    int xy= s->block_index[0];
529
    uint16_t time_pp= s->pp_time;
530
    uint16_t time_pb= s->pb_time;
531
    int i;
532 c40c3482 Michael Niedermayer
    
533 1457ab52 Michael Niedermayer
    //FIXME avoid divides
534 7bc9090a Michael Niedermayer
    
535
    if(IS_8X8(colocated_mb_type)){
536 1457ab52 Michael Niedermayer
        s->mv_type = MV_TYPE_8X8;
537
        for(i=0; i<4; i++){
538
            xy= s->block_index[i];
539 8d7ec294 Wolfgang Hesseler
            s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
540
            s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
541
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
542
                                : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
543
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1] 
544
                                : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
545 1457ab52 Michael Niedermayer
        }
546 7bc9090a Michael Niedermayer
        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
547
    } else if(IS_INTERLACED(colocated_mb_type)){
548 1457ab52 Michael Niedermayer
        s->mv_type = MV_TYPE_FIELD;
549
        for(i=0; i<2; i++){
550
            if(s->top_field_first){
551 bb198e19 Michael Niedermayer
                time_pp= s->pp_field_time - s->p_field_select_table[i][mb_index] + i;
552
                time_pb= s->pb_field_time - s->p_field_select_table[i][mb_index] + i;
553 1457ab52 Michael Niedermayer
            }else{
554 bb198e19 Michael Niedermayer
                time_pp= s->pp_field_time + s->p_field_select_table[i][mb_index] - i;
555
                time_pb= s->pb_field_time + s->p_field_select_table[i][mb_index] - i;
556 1457ab52 Michael Niedermayer
            }
557 bb198e19 Michael Niedermayer
            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
558
            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
559
            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
560
                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
561
            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 
562
                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
563 1457ab52 Michael Niedermayer
        }
564 7bc9090a Michael Niedermayer
        return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
565
    }else{
566 8d7ec294 Wolfgang Hesseler
        s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
567
        s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
568
        s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->next_picture.motion_val[0][xy][0]
569
                            : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
570
        s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->next_picture.motion_val[0][xy][1] 
571
                            : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
572 7bc9090a Michael Niedermayer
        if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
573
            s->mv_type= MV_TYPE_16X16;
574
        else
575
            s->mv_type= MV_TYPE_8X8;
576
        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
577 1457ab52 Michael Niedermayer
    }
578
}
579
580 7d1c3fc1 Michael Niedermayer
void ff_h263_update_motion_val(MpegEncContext * s){
581
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
582
               //FIXME a lot of thet is only needed for !low_delay
583
    const int wrap = s->block_wrap[0];
584
    const int xy = s->block_index[0];
585
    
586
    s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; 
587
588
    if(s->mv_type != MV_TYPE_8X8){
589
        int motion_x, motion_y;
590
        if (s->mb_intra) {
591
            motion_x = 0;
592
            motion_y = 0;
593
        } else if (s->mv_type == MV_TYPE_16X16) {
594
            motion_x = s->mv[0][0][0];
595
            motion_y = s->mv[0][0][1];
596
        } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
597
            int i;
598
            motion_x = s->mv[0][0][0] + s->mv[0][1][0];
599
            motion_y = s->mv[0][0][1] + s->mv[0][1][1];
600
            motion_x = (motion_x>>1) | (motion_x&1);
601
            for(i=0; i<2; i++){
602 bb198e19 Michael Niedermayer
                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
603
                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
604
                s->p_field_select_table[i][mb_xy]= s->field_select[0][i];
605 7d1c3fc1 Michael Niedermayer
            }
606
        }
607
        
608
        /* no update if 8X8 because it has been done during parsing */
609 8d7ec294 Wolfgang Hesseler
        s->current_picture.motion_val[0][xy][0] = motion_x;
610
        s->current_picture.motion_val[0][xy][1] = motion_y;
611
        s->current_picture.motion_val[0][xy + 1][0] = motion_x;
612
        s->current_picture.motion_val[0][xy + 1][1] = motion_y;
613
        s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
614
        s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
615
        s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
616
        s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
617 7d1c3fc1 Michael Niedermayer
    }
618
619
    if(s->encoding){ //FIXME encoding MUST be cleaned up
620
        if (s->mv_type == MV_TYPE_8X8) 
621
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
622 f7190f73 Michael Niedermayer
        else if(s->mb_intra)
623
            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
624 7d1c3fc1 Michael Niedermayer
        else
625
            s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
626
    }
627
}
628
629 bbed9259 Michael Niedermayer
#ifdef CONFIG_ENCODERS
630 f2f6134b Michael Niedermayer
631
static inline int get_p_cbp(MpegEncContext * s,
632
                      DCTELEM block[6][64],
633
                      int motion_x, int motion_y){
634
    int cbp, i;
635
636
    if(s->flags & CODEC_FLAG_CBP_RD){
637
        int best_cbpy_score= INT_MAX;
638
        int best_cbpc_score= INT_MAX;
639 9b879566 Michel Bardiaux
        int cbpc = (-1), cbpy= (-1);
640 f2f6134b Michael Niedermayer
        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
641 158c7f05 Michael Niedermayer
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
642 f2f6134b Michael Niedermayer
643
        for(i=0; i<4; i++){
644
            int score= inter_MCBPC_bits[i + offset] * lambda;
645
            if(i&1) score += s->coded_score[5];
646
            if(i&2) score += s->coded_score[4];
647
648
            if(score < best_cbpc_score){
649
                best_cbpc_score= score;
650
                cbpc= i;
651
            }
652
        }
653
654
        for(i=0; i<16; i++){
655
            int score= cbpy_tab[i ^ 0xF][1] * lambda;
656
            if(i&1) score += s->coded_score[3];
657
            if(i&2) score += s->coded_score[2];
658
            if(i&4) score += s->coded_score[1];
659
            if(i&8) score += s->coded_score[0];
660
661
            if(score < best_cbpy_score){
662
                best_cbpy_score= score;
663
                cbpy= i;
664
            }
665
        }
666
        cbp= cbpc + 4*cbpy;
667
        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
668
            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
669
                cbp= 0;
670
        }
671
672
        for (i = 0; i < 6; i++) {
673
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
674
                s->block_last_index[i]= -1;
675
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
676
            }
677
        }
678
    }else{
679
        cbp= 0;
680
        for (i = 0; i < 6; i++) {
681
            if (s->block_last_index[i] >= 0)
682
                cbp |= 1 << (5 - i);
683
        }
684
    }
685
    return cbp;
686
}
687
688
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
689
                            int motion_x, int motion_y, int mb_type){
690
    int cbp=0, i;
691
692
    if(s->flags & CODEC_FLAG_CBP_RD){
693
        int score=0;
694 158c7f05 Michael Niedermayer
        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
695 f2f6134b Michael Niedermayer
        
696
        for(i=0; i<6; i++){
697
            if(s->coded_score[i] < 0){
698
                score += s->coded_score[i];
699
                cbp |= 1 << (5 - i);
700
            }
701
        }
702
        
703
        if(cbp){
704
            int zero_score= -6;
705
            if ((motion_x | motion_y | s->dquant | mb_type) == 0){
706
                zero_score-= 4; //2*MV + mb_type + cbp bit
707
            }
708
709
            zero_score*= lambda;
710
            if(zero_score <= score){
711
                cbp=0;
712
            }
713
        }
714
715
        for (i = 0; i < 6; i++) {
716
            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
717
                s->block_last_index[i]= -1;
718
                memset(s->block[i], 0, sizeof(DCTELEM)*64);
719
            }
720
        }
721
    }else{
722
        for (i = 0; i < 6; i++) {
723
            if (s->block_last_index[i] >= 0)
724
                cbp |= 1 << (5 - i);
725
        }
726
    }
727
    return cbp;
728
}
729
730 d6231b9e Michael Niedermayer
void mpeg4_encode_mb(MpegEncContext * s,
731
                    DCTELEM block[6][64],
732
                    int motion_x, int motion_y)
733
{
734 5c91a675 Zdenek Kabelac
    int cbpc, cbpy, pred_x, pred_y;
735 92073d01 Michael Niedermayer
    PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
736
    PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
737
    PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
738
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
739 c5d309f2 Michael Niedermayer
    const int dquant_code[5]= {1,0,9,2,3};
740 644d98a4 Juanjo
    
741 d6231b9e Michael Niedermayer
    //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
742
    if (!s->mb_intra) {
743 f2f6134b Michael Niedermayer
        int i, cbp;
744
        
745 9dbcbd92 Michael Niedermayer
        if(s->pict_type==B_TYPE){
746
            static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
747
            int mb_type=  mb_type_table[s->mv_dir];
748 bb198e19 Michael Niedermayer
749 9dbcbd92 Michael Niedermayer
            if(s->mb_x==0){
750 bb198e19 Michael Niedermayer
                for(i=0; i<2; i++){
751
                    s->last_mv[i][0][0]= 
752
                    s->last_mv[i][0][1]= 
753
                    s->last_mv[i][1][0]= 
754
                    s->last_mv[i][1][1]= 0;
755
                }
756 9dbcbd92 Michael Niedermayer
            }
757 c5d309f2 Michael Niedermayer
            
758
            assert(s->dquant>=-2 && s->dquant<=2);
759
            assert((s->dquant&1)==0);
760
            assert(mb_type>=0);
761 9dbcbd92 Michael Niedermayer
762
            /* nothing to do if this MB was skiped in the next P Frame */
763 7bc9090a Michael Niedermayer
            if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
764 9dbcbd92 Michael Niedermayer
                s->skip_count++;
765
                s->mv[0][0][0]= 
766
                s->mv[0][0][1]= 
767
                s->mv[1][0][0]= 
768
                s->mv[1][0][1]= 0;
769 91029be7 Michael Niedermayer
                s->mv_dir= MV_DIR_FORWARD; //doesnt matter
770 c5d309f2 Michael Niedermayer
                s->qscale -= s->dquant;
771 1e491e29 Michael Niedermayer
//                s->mb_skiped=1;
772
773 9dbcbd92 Michael Niedermayer
                return;
774
            }
775 1457ab52 Michael Niedermayer
            
776 f2f6134b Michael Niedermayer
            cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
777
            
778 9dbcbd92 Michael Niedermayer
            if ((cbp | motion_x | motion_y | mb_type) ==0) {
779
                /* direct MB with MV={0,0} */
780 c5d309f2 Michael Niedermayer
                assert(s->dquant==0);
781
                
782 9dbcbd92 Michael Niedermayer
                put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
783 92073d01 Michael Niedermayer
784
                if(interleaved_stats){
785
                    s->misc_bits++;
786
                    s->last_bits++;
787
                }
788 9dbcbd92 Michael Niedermayer
                s->skip_count++;
789
                return;
790
            }
791 1e491e29 Michael Niedermayer
            
792 9dbcbd92 Michael Niedermayer
            put_bits(&s->pb, 1, 0);        /* mb coded modb1=0 */
793
            put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
794
            put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
795
            if(cbp) put_bits(&s->pb, 6, cbp);
796
            
797 c5d309f2 Michael Niedermayer
            if(cbp && mb_type){
798
                if(s->dquant)
799
                    put_bits(&s->pb, 2, (s->dquant>>2)+3);
800
                else
801
                    put_bits(&s->pb, 1, 0);
802
            }else
803
                s->qscale -= s->dquant;
804 fcb48651 Michael Niedermayer
            
805
            if(!s->progressive_sequence){
806
                if(cbp)
807
                    put_bits(&s->pb, 1, s->interlaced_dct);
808
                if(mb_type) // not diect mode
809 bb198e19 Michael Niedermayer
                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
810 fcb48651 Michael Niedermayer
            }
811 9dbcbd92 Michael Niedermayer
812 92073d01 Michael Niedermayer
            if(interleaved_stats){
813 4d2a4834 Michael Niedermayer
                s->misc_bits+= get_bits_diff(s);
814 92073d01 Michael Niedermayer
            }
815 cf8039b2 Michael Niedermayer
816 bb198e19 Michael Niedermayer
            if(mb_type == 0){
817
                assert(s->mv_dir & MV_DIRECT);
818 9dbcbd92 Michael Niedermayer
                h263_encode_motion(s, motion_x, 1);
819
                h263_encode_motion(s, motion_y, 1);                
820 66370d3f Michael Niedermayer
                s->b_count++;
821
                s->f_count++;
822 bb198e19 Michael Niedermayer
            }else{
823
                assert(mb_type > 0 && mb_type < 4);
824
                if(s->mv_type != MV_TYPE_FIELD){
825
                    if(s->mv_dir & MV_DIR_FORWARD){
826
                        h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
827
                        h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
828
                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
829
                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
830
                        s->f_count++;
831
                    }
832
                    if(s->mv_dir & MV_DIR_BACKWARD){
833
                        h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
834
                        h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
835
                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
836
                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
837
                        s->b_count++;
838
                    }
839
                }else{
840
                    if(s->mv_dir & MV_DIR_FORWARD){
841
                        put_bits(&s->pb, 1, s->field_select[0][0]);
842
                        put_bits(&s->pb, 1, s->field_select[0][1]);
843
                    }
844
                    if(s->mv_dir & MV_DIR_BACKWARD){
845
                        put_bits(&s->pb, 1, s->field_select[1][0]);
846
                        put_bits(&s->pb, 1, s->field_select[1][1]);
847
                    }
848
                    if(s->mv_dir & MV_DIR_FORWARD){
849
                        for(i=0; i<2; i++){
850
                            h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0]  , s->f_code);
851
                            h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
852
                            s->last_mv[0][i][0]= s->mv[0][i][0];
853
                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;
854
                        }
855
                        s->f_count++;
856
                    }
857
                    if(s->mv_dir & MV_DIR_BACKWARD){
858
                        for(i=0; i<2; i++){
859
                            h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0]  , s->b_code);
860
                            h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
861
                            s->last_mv[1][i][0]= s->mv[1][i][0];
862
                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;
863
                        }
864
                        s->b_count++;
865
                    }
866
                }
867 9dbcbd92 Michael Niedermayer
            }
868 92073d01 Michael Niedermayer
869
            if(interleaved_stats){
870 4d2a4834 Michael Niedermayer
                s->mv_bits+= get_bits_diff(s);
871 92073d01 Michael Niedermayer
            }
872 d6231b9e Michael Niedermayer
873 9dbcbd92 Michael Niedermayer
            /* encode each block */
874
            for (i = 0; i < 6; i++) {
875 2ad1516a Michael Niedermayer
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
876 92073d01 Michael Niedermayer
            }
877
878
            if(interleaved_stats){
879 4d2a4834 Michael Niedermayer
                s->p_tex_bits+= get_bits_diff(s);
880 9dbcbd92 Michael Niedermayer
            }
881 bb198e19 Michael Niedermayer
882 9dbcbd92 Michael Niedermayer
        }else{ /* s->pict_type==B_TYPE */
883 f2f6134b Michael Niedermayer
            cbp= get_p_cbp(s, block, motion_x, motion_y);
884
        
885 c5d309f2 Michael Niedermayer
            if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
886 ee6f7861 Michael Niedermayer
                /* check if the B frames can skip it too, as we must skip it if we skip here 
887
                   why didnt they just compress the skip-mb bits instead of reusing them ?! */
888
                if(s->max_b_frames>0){
889
                    int i;
890 e71a4f74 Michael Niedermayer
                    int x,y, offset;
891
                    uint8_t *p_pic;
892
893
                    x= s->mb_x*16;
894
                    y= s->mb_y*16;
895
                    if(x+16 > s->width)  x= s->width-16;
896
                    if(y+16 > s->height) y= s->height-16;
897
898
                    offset= x + y*s->linesize;
899 1e491e29 Michael Niedermayer
                    p_pic= s->new_picture.data[0] + offset;
900 e71a4f74 Michael Niedermayer
                    
901 ee6f7861 Michael Niedermayer
                    s->mb_skiped=1;
902
                    for(i=0; i<s->max_b_frames; i++){
903 d697b89b Michael Niedermayer
                        uint8_t *b_pic;
904
                        int diff;
905 1e491e29 Michael Niedermayer
                        Picture *pic= s->reordered_input_picture[i+1];
906 d697b89b Michael Niedermayer
907 1e491e29 Michael Niedermayer
                        if(pic==NULL || pic->pict_type!=B_TYPE) break;
908 d697b89b Michael Niedermayer
909 1e491e29 Michael Niedermayer
                        b_pic= pic->data[0] + offset + 16; //FIXME +16
910 bb198e19 Michael Niedermayer
                        diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
911 e71a4f74 Michael Niedermayer
                        if(diff>s->qscale*70){ //FIXME check that 70 is optimal
912 ee6f7861 Michael Niedermayer
                            s->mb_skiped=0;
913
                            break;
914
                        }
915
                    }
916
                }else
917
                    s->mb_skiped=1; 
918
919
                if(s->mb_skiped==1){
920
                    /* skip macroblock */
921
                    put_bits(&s->pb, 1, 1);
922 92073d01 Michael Niedermayer
923
                    if(interleaved_stats){
924
                        s->misc_bits++;
925
                        s->last_bits++;
926
                    }
927 ee6f7861 Michael Niedermayer
                    s->skip_count++;
928 6d71b382 Michael Niedermayer
                    
929 ee6f7861 Michael Niedermayer
                    return;
930
                }
931 9dbcbd92 Michael Niedermayer
            }
932 e71a4f74 Michael Niedermayer
933 9dbcbd92 Michael Niedermayer
            put_bits(&s->pb, 1, 0);        /* mb coded */
934 f7190f73 Michael Niedermayer
            cbpc = cbp & 3;
935
            cbpy = cbp >> 2;
936
            cbpy ^= 0xf;
937 9dbcbd92 Michael Niedermayer
            if(s->mv_type==MV_TYPE_16X16){
938 c5d309f2 Michael Niedermayer
                if(s->dquant) cbpc+= 8;
939 9dbcbd92 Michael Niedermayer
                put_bits(&s->pb,
940
                        inter_MCBPC_bits[cbpc],
941
                        inter_MCBPC_code[cbpc]);
942 c5d309f2 Michael Niedermayer
943 92073d01 Michael Niedermayer
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
944 c5d309f2 Michael Niedermayer
                if(s->dquant)
945
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
946 fcb48651 Michael Niedermayer
947
                if(!s->progressive_sequence){
948
                    if(cbp)
949
                        put_bits(pb2, 1, s->interlaced_dct);
950 bb198e19 Michael Niedermayer
                    put_bits(pb2, 1, 0);
951 fcb48651 Michael Niedermayer
                }
952 9dbcbd92 Michael Niedermayer
                    
953 92073d01 Michael Niedermayer
                if(interleaved_stats){
954 4d2a4834 Michael Niedermayer
                    s->misc_bits+= get_bits_diff(s);
955 92073d01 Michael Niedermayer
                }
956 d6231b9e Michael Niedermayer
957 9dbcbd92 Michael Niedermayer
                /* motion vectors: 16x16 mode */
958
                h263_pred_motion(s, 0, &pred_x, &pred_y);
959
            
960
                h263_encode_motion(s, motion_x - pred_x, s->f_code);
961
                h263_encode_motion(s, motion_y - pred_y, s->f_code);
962 bb198e19 Michael Niedermayer
            }else if(s->mv_type==MV_TYPE_FIELD){
963
                if(s->dquant) cbpc+= 8;
964
                put_bits(&s->pb,
965
                        inter_MCBPC_bits[cbpc],
966
                        inter_MCBPC_code[cbpc]);
967
968
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
969
                if(s->dquant)
970
                    put_bits(pb2, 2, dquant_code[s->dquant+2]);
971
972
                assert(!s->progressive_sequence);
973
                if(cbp)
974
                    put_bits(pb2, 1, s->interlaced_dct);
975
                put_bits(pb2, 1, 1);
976
                    
977
                if(interleaved_stats){
978
                    s->misc_bits+= get_bits_diff(s);
979
                }
980
981
                /* motion vectors: 16x8 interlaced mode */
982
                h263_pred_motion(s, 0, &pred_x, &pred_y);
983
                pred_y /=2;
984
                
985
                put_bits(&s->pb, 1, s->field_select[0][0]);
986
                put_bits(&s->pb, 1, s->field_select[0][1]);
987
            
988
                h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
989
                h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
990
                h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
991
                h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
992 9dbcbd92 Michael Niedermayer
            }else{
993 bb198e19 Michael Niedermayer
                assert(s->mv_type==MV_TYPE_8X8);
994 9dbcbd92 Michael Niedermayer
                put_bits(&s->pb,
995 f7190f73 Michael Niedermayer
                        inter_MCBPC_bits[cbpc+16],
996
                        inter_MCBPC_code[cbpc+16]);
997 92073d01 Michael Niedermayer
                put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
998 9dbcbd92 Michael Niedermayer
999 49943a18 Michael Niedermayer
                if(!s->progressive_sequence){
1000
                    if(cbp)
1001
                        put_bits(pb2, 1, s->interlaced_dct);
1002
                }
1003
    
1004 92073d01 Michael Niedermayer
                if(interleaved_stats){
1005 4d2a4834 Michael Niedermayer
                    s->misc_bits+= get_bits_diff(s);
1006 92073d01 Michael Niedermayer
                }
1007 9dbcbd92 Michael Niedermayer
1008
                for(i=0; i<4; i++){
1009
                    /* motion vectors: 8x8 mode*/
1010
                    h263_pred_motion(s, i, &pred_x, &pred_y);
1011
1012 8d7ec294 Wolfgang Hesseler
                    h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
1013
                    h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1014 9dbcbd92 Michael Niedermayer
                }
1015 cf8039b2 Michael Niedermayer
            }
1016 92073d01 Michael Niedermayer
1017
            if(interleaved_stats){ 
1018 4d2a4834 Michael Niedermayer
                s->mv_bits+= get_bits_diff(s);
1019 92073d01 Michael Niedermayer
            }
1020 098eefe1 Michael Niedermayer
1021 9dbcbd92 Michael Niedermayer
            /* encode each block */
1022
            for (i = 0; i < 6; i++) {
1023 2ad1516a Michael Niedermayer
                mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
1024 92073d01 Michael Niedermayer
            }
1025
1026
            if(interleaved_stats){
1027 4d2a4834 Michael Niedermayer
                s->p_tex_bits+= get_bits_diff(s);
1028 9dbcbd92 Michael Niedermayer
            }
1029 66370d3f Michael Niedermayer
            s->f_count++;
1030 d6231b9e Michael Niedermayer
        }
1031
    } else {
1032 9dbcbd92 Michael Niedermayer
        int cbp;
1033 d6231b9e Michael Niedermayer
        int dc_diff[6];   //dc values with the dc prediction subtracted 
1034
        int dir[6];  //prediction direction
1035
        int zigzag_last_index[6];
1036 0c1a9eda Zdenek Kabelac
        uint8_t *scan_table[6];
1037 5c91a675 Zdenek Kabelac
        int i;
1038 d6231b9e Michael Niedermayer
1039
        for(i=0; i<6; i++){
1040
            const int level= block[i][0];
1041 0c1a9eda Zdenek Kabelac
            uint16_t *dc_ptr;
1042 d6231b9e Michael Niedermayer
1043 8f8402e4 Michael Niedermayer
            dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
1044 d6231b9e Michael Niedermayer
            if (i < 4) {
1045
                *dc_ptr = level * s->y_dc_scale;
1046
            } else {
1047
                *dc_ptr = level * s->c_dc_scale;
1048
            }
1049
        }
1050
1051 8d8c0294 Michael Niedermayer
        if(s->flags & CODEC_FLAG_AC_PRED){
1052
            s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1053
            if(!s->ac_pred)
1054
                restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1055 d6231b9e Michael Niedermayer
        }else{
1056
            for(i=0; i<6; i++)
1057 2ad1516a Michael Niedermayer
                scan_table[i]= s->intra_scantable.permutated;
1058 d6231b9e Michael Niedermayer
        }
1059
1060
        /* compute cbp */
1061
        cbp = 0;
1062
        for (i = 0; i < 6; i++) {
1063
            if (s->block_last_index[i] >= 1)
1064
                cbp |= 1 << (5 - i);
1065
        }
1066
1067
        cbpc = cbp & 3;
1068
        if (s->pict_type == I_TYPE) {
1069 c5d309f2 Michael Niedermayer
            if(s->dquant) cbpc+=4;
1070 d6231b9e Michael Niedermayer
            put_bits(&s->pb,
1071
                intra_MCBPC_bits[cbpc],
1072
                intra_MCBPC_code[cbpc]);
1073
        } else {
1074 c5d309f2 Michael Niedermayer
            if(s->dquant) cbpc+=8;
1075 d6231b9e Michael Niedermayer
            put_bits(&s->pb, 1, 0);        /* mb coded */
1076
            put_bits(&s->pb,
1077
                inter_MCBPC_bits[cbpc + 4],
1078
                inter_MCBPC_code[cbpc + 4]);
1079
        }
1080 92073d01 Michael Niedermayer
        put_bits(pb2, 1, s->ac_pred);
1081 d6231b9e Michael Niedermayer
        cbpy = cbp >> 2;
1082 92073d01 Michael Niedermayer
        put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1083 c5d309f2 Michael Niedermayer
        if(s->dquant)
1084
            put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1085 d6231b9e Michael Niedermayer
1086 fcb48651 Michael Niedermayer
        if(!s->progressive_sequence){
1087
            put_bits(dc_pb, 1, s->interlaced_dct);
1088
        }
1089
1090 92073d01 Michael Niedermayer
        if(interleaved_stats){
1091 4d2a4834 Michael Niedermayer
            s->misc_bits+= get_bits_diff(s);
1092 92073d01 Michael Niedermayer
        }
1093 098eefe1 Michael Niedermayer
1094 d6231b9e Michael Niedermayer
        /* encode each block */
1095
        for (i = 0; i < 6; i++) {
1096 92073d01 Michael Niedermayer
            mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1097 d6231b9e Michael Niedermayer
        }
1098
1099 92073d01 Michael Niedermayer
        if(interleaved_stats){
1100 4d2a4834 Michael Niedermayer
            s->i_tex_bits+= get_bits_diff(s);
1101 92073d01 Michael Niedermayer
        }
1102 098eefe1 Michael Niedermayer
        s->i_count++;
1103
1104 d6231b9e Michael Niedermayer
        /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1105 8d8c0294 Michael Niedermayer
        if(s->ac_pred)
1106
            restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1107 d6231b9e Michael Niedermayer
    }
1108
}
1109
1110 de6d9b64 Fabrice Bellard
void h263_encode_mb(MpegEncContext * s,
1111
                    DCTELEM block[6][64],
1112
                    int motion_x, int motion_y)
1113
{
1114
    int cbpc, cbpy, i, cbp, pred_x, pred_y;
1115 0c1a9eda Zdenek Kabelac
    int16_t pred_dc;
1116
    int16_t rec_intradc[6];
1117
    uint16_t *dc_ptr[6];
1118 d4f5d74a Garrick Meeker
    const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1119 9e4c6948 Michael Niedermayer
    const int dquant_code[5]= {1,0,9,2,3};
1120 ef5b1b5a Juanjo
           
1121
    //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1122 9dbcbd92 Michael Niedermayer
    if (!s->mb_intra) {
1123 ef5b1b5a Juanjo
        /* compute cbp */
1124 f2f6134b Michael Niedermayer
        cbp= get_p_cbp(s, block, motion_x, motion_y);
1125
1126 8cb5d4c0 Michael Niedermayer
        if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1127 9dbcbd92 Michael Niedermayer
            /* skip macroblock */
1128
            put_bits(&s->pb, 1, 1);
1129 d4f5d74a Garrick Meeker
            if(interleaved_stats){
1130
                s->misc_bits++;
1131
                s->last_bits++;
1132
            }
1133 65a24d0b Michael Niedermayer
            s->skip_count++;
1134
1135 9dbcbd92 Michael Niedermayer
            return;
1136
        }
1137 ef5b1b5a Juanjo
        put_bits(&s->pb, 1, 0);        /* mb coded */
1138 f7190f73 Michael Niedermayer
        
1139 9dbcbd92 Michael Niedermayer
        cbpc = cbp & 3;
1140
        cbpy = cbp >> 2;
1141 dba019da Michael Niedermayer
        if(s->alt_inter_vlc==0 || cbpc!=3)
1142
            cbpy ^= 0xF;
1143
        if(s->dquant) cbpc+= 8;
1144 f7190f73 Michael Niedermayer
        if(s->mv_type==MV_TYPE_16X16){
1145
            put_bits(&s->pb,
1146
                    inter_MCBPC_bits[cbpc],
1147
                    inter_MCBPC_code[cbpc]);
1148 9dbcbd92 Michael Niedermayer
1149 f7190f73 Michael Niedermayer
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1150
            if(s->dquant)
1151
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1152
                
1153
            if(interleaved_stats){
1154
                s->misc_bits+= get_bits_diff(s);
1155
            }
1156 d4f5d74a Garrick Meeker
1157 f7190f73 Michael Niedermayer
            /* motion vectors: 16x16 mode */
1158
            h263_pred_motion(s, 0, &pred_x, &pred_y);
1159
            
1160
            if (!s->umvplus) {  
1161 b40cd4e0 Michael Niedermayer
                h263_encode_motion(s, motion_x - pred_x, 1);
1162
                h263_encode_motion(s, motion_y - pred_y, 1);
1163 f7190f73 Michael Niedermayer
            }
1164
            else {
1165
                h263p_encode_umotion(s, motion_x - pred_x);
1166
                h263p_encode_umotion(s, motion_y - pred_y);
1167
                if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1168
                    /* To prevent Start Code emulation */
1169
                    put_bits(&s->pb,1,1);
1170
            }
1171
        }else{
1172
            put_bits(&s->pb,
1173
                    inter_MCBPC_bits[cbpc+16],
1174
                    inter_MCBPC_code[cbpc+16]);
1175
            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1176
            if(s->dquant)
1177
                put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1178
1179
            if(interleaved_stats){
1180
                s->misc_bits+= get_bits_diff(s);
1181
            }
1182
1183
            for(i=0; i<4; i++){
1184
                /* motion vectors: 8x8 mode*/
1185
                h263_pred_motion(s, i, &pred_x, &pred_y);
1186
1187 8d7ec294 Wolfgang Hesseler
                motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1188
                motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1189 f7190f73 Michael Niedermayer
                if (!s->umvplus) {  
1190 b40cd4e0 Michael Niedermayer
                    h263_encode_motion(s, motion_x - pred_x, 1);
1191
                    h263_encode_motion(s, motion_y - pred_y, 1);
1192 f7190f73 Michael Niedermayer
                }
1193
                else {
1194
                    h263p_encode_umotion(s, motion_x - pred_x);
1195
                    h263p_encode_umotion(s, motion_y - pred_y);
1196
                    if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1197
                        /* To prevent Start Code emulation */
1198
                        put_bits(&s->pb,1,1);
1199
                }
1200
            }
1201 9dbcbd92 Michael Niedermayer
        }
1202 d4f5d74a Garrick Meeker
1203
        if(interleaved_stats){
1204
            s->mv_bits+= get_bits_diff(s);
1205
        }
1206 ef5b1b5a Juanjo
    } else {
1207 68b94c35 Michael Niedermayer
        assert(s->mb_intra);
1208 ef5b1b5a Juanjo
        
1209
        cbp = 0;
1210 fb079883 Michael Niedermayer
        if (s->h263_aic) {
1211 ef5b1b5a Juanjo
            /* Predict DC */
1212 fb079883 Michael Niedermayer
            for(i=0; i<6; i++) {
1213 0c1a9eda Zdenek Kabelac
                int16_t level = block[i][0];
1214 fb079883 Michael Niedermayer
                int scale;
1215
                
1216
                if(i<4) scale= s->y_dc_scale;
1217
                else    scale= s->c_dc_scale;
1218
1219 ef5b1b5a Juanjo
                pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1220
                level -= pred_dc;
1221
                /* Quant */
1222 fb079883 Michael Niedermayer
                if (level >= 0)
1223
                    level = (level + (scale>>1))/scale;
1224 ef5b1b5a Juanjo
                else
1225 fb079883 Michael Niedermayer
                    level = (level - (scale>>1))/scale;
1226 ef5b1b5a Juanjo
                    
1227
                /* AIC can change CBP */
1228
                if (level == 0 && s->block_last_index[i] == 0)
1229
                    s->block_last_index[i] = -1;
1230 fb079883 Michael Niedermayer
1231
                if(!s->modified_quant){
1232
                    if (level < -127)
1233
                        level = -127;
1234
                    else if (level > 127)
1235
                        level = 127;
1236
                }
1237
1238 ef5b1b5a Juanjo
                block[i][0] = level;
1239
                /* Reconstruction */ 
1240 fb079883 Michael Niedermayer
                rec_intradc[i] = scale*level + pred_dc;
1241 ef5b1b5a Juanjo
                /* Oddify */
1242
                rec_intradc[i] |= 1;
1243
                //if ((rec_intradc[i] % 2) == 0)
1244
                //    rec_intradc[i]++;
1245
                /* Clipping */
1246
                if (rec_intradc[i] < 0)
1247
                    rec_intradc[i] = 0;
1248
                else if (rec_intradc[i] > 2047)
1249
                    rec_intradc[i] = 2047;
1250
                                
1251
                /* Update AC/DC tables */
1252
                *dc_ptr[i] = rec_intradc[i];
1253 fb079883 Michael Niedermayer
                if (s->block_last_index[i] >= 0)
1254
                    cbp |= 1 << (5 - i);
1255
            }
1256
        }else{
1257
            for(i=0; i<6; i++) {
1258
                /* compute cbp */
1259
                if (s->block_last_index[i] >= 1)
1260
                    cbp |= 1 << (5 - i);
1261 ef5b1b5a Juanjo
            }
1262
        }
1263 de6d9b64 Fabrice Bellard
1264 ef5b1b5a Juanjo
        cbpc = cbp & 3;
1265
        if (s->pict_type == I_TYPE) {
1266 9e4c6948 Michael Niedermayer
            if(s->dquant) cbpc+=4;
1267 ef5b1b5a Juanjo
            put_bits(&s->pb,
1268
                intra_MCBPC_bits[cbpc],
1269
                intra_MCBPC_code[cbpc]);
1270
        } else {
1271 9e4c6948 Michael Niedermayer
            if(s->dquant) cbpc+=8;
1272 ef5b1b5a Juanjo
            put_bits(&s->pb, 1, 0);        /* mb coded */
1273
            put_bits(&s->pb,
1274
                inter_MCBPC_bits[cbpc + 4],
1275
                inter_MCBPC_code[cbpc + 4]);
1276
        }
1277
        if (s->h263_aic) {
1278
            /* XXX: currently, we do not try to use ac prediction */
1279
            put_bits(&s->pb, 1, 0);        /* no AC prediction */
1280
        }
1281
        cbpy = cbp >> 2;
1282
        put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1283 9e4c6948 Michael Niedermayer
        if(s->dquant)
1284
            put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1285 d4f5d74a Garrick Meeker
1286
        if(interleaved_stats){
1287
            s->misc_bits+= get_bits_diff(s);
1288
        }
1289 de6d9b64 Fabrice Bellard
    }
1290
1291 ef5b1b5a Juanjo
    for(i=0; i<6; i++) {
1292
        /* encode each block */
1293 44a2950f Michael Niedermayer
        h263_encode_block(s, block[i], i);
1294 ef5b1b5a Juanjo
    
1295
        /* Update INTRADC for decoding */
1296
        if (s->h263_aic && s->mb_intra) {
1297
            block[i][0] = rec_intradc[i];
1298
            
1299
        }
1300
    }
1301 d4f5d74a Garrick Meeker
1302
    if(interleaved_stats){
1303
        if (!s->mb_intra) {
1304
            s->p_tex_bits+= get_bits_diff(s);
1305
            s->f_count++;
1306
        }else{
1307
            s->i_tex_bits+= get_bits_diff(s);
1308
            s->i_count++;
1309
        }
1310
    }
1311 ef5b1b5a Juanjo
}
1312 bbed9259 Michael Niedermayer
#endif
1313 ef5b1b5a Juanjo
1314 cdb4e730 Michael Niedermayer
void ff_h263_loop_filter(MpegEncContext * s){
1315 332f9ac4 Michael Niedermayer
    int qp_c;
1316
    const int linesize  = s->linesize;
1317
    const int uvlinesize= s->uvlinesize;
1318
    const int xy = s->mb_y * s->mb_stride + s->mb_x;
1319
    uint8_t *dest_y = s->dest[0];
1320
    uint8_t *dest_cb= s->dest[1];
1321
    uint8_t *dest_cr= s->dest[2];
1322
    
1323
//    if(s->pict_type==B_TYPE && !s->readable) return;
1324
1325
    /*
1326
       Diag Top
1327
       Left Center
1328
    */
1329
    if(!IS_SKIP(s->current_picture.mb_type[xy])){
1330
        qp_c= s->qscale;
1331
        s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1332
        s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1333
    }else
1334
        qp_c= 0;
1335
1336
    if(s->mb_y){
1337
        int qp_dt, qp_t, qp_tc;
1338
1339
        if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1340
            qp_t=0;
1341
        else 
1342
            qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1343
1344
        if(qp_c) 
1345
            qp_tc= qp_c;
1346
        else
1347
            qp_tc= qp_t;
1348
            
1349
        if(qp_tc){
1350
            const int chroma_qp= s->chroma_qscale_table[qp_tc];
1351
            s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1352
            s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1353
        
1354
            s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1355
            s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1356
        }
1357
        
1358
        if(qp_t)
1359
            s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1360
        
1361
        if(s->mb_x){
1362
            if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1363
                qp_dt= qp_t;
1364
            else
1365
                qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1366
            
1367
            if(qp_dt){
1368
                const int chroma_qp= s->chroma_qscale_table[qp_dt];
1369
                s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1370
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1371
                s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1372
            }
1373
        }
1374
    }
1375
1376
    if(qp_c){
1377
        s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1378
        if(s->mb_y + 1 == s->mb_height)
1379
            s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1380
    }
1381
    
1382
    if(s->mb_x){
1383
        int qp_lc;
1384
        if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1385
            qp_lc= qp_c;
1386
        else
1387
            qp_lc= s->current_picture.qscale_table[xy-1];
1388
        
1389
        if(qp_lc){
1390
            s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1391
            if(s->mb_y + 1 == s->mb_height){
1392
                const int chroma_qp= s->chroma_qscale_table[qp_lc];
1393
                s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1394
                s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1395
                s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1396
            }
1397
        }
1398
    }
1399
}
1400
1401 0c1a9eda Zdenek Kabelac
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1402 ef5b1b5a Juanjo
{
1403
    int x, y, wrap, a, c, pred_dc, scale;
1404 0c1a9eda Zdenek Kabelac
    int16_t *dc_val, *ac_val;
1405 ef5b1b5a Juanjo
1406
    /* find prediction */
1407
    if (n < 4) {
1408
        x = 2 * s->mb_x + 1 + (n & 1);
1409
        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1410
        wrap = s->mb_width * 2 + 2;
1411
        dc_val = s->dc_val[0];
1412
        ac_val = s->ac_val[0][0];
1413
        scale = s->y_dc_scale;
1414
    } else {
1415
        x = s->mb_x + 1;
1416
        y = s->mb_y + 1;
1417
        wrap = s->mb_width + 2;
1418
        dc_val = s->dc_val[n - 4 + 1];
1419
        ac_val = s->ac_val[n - 4 + 1][0];
1420
        scale = s->c_dc_scale;
1421 de6d9b64 Fabrice Bellard
    }
1422 ef5b1b5a Juanjo
    /* B C
1423
     * A X 
1424
     */
1425
    a = dc_val[(x - 1) + (y) * wrap];
1426
    c = dc_val[(x) + (y - 1) * wrap];
1427
    
1428
    /* No prediction outside GOB boundary */
1429 92073d01 Michael Niedermayer
    if (s->first_slice_line && ((n < 2) || (n > 3)))
1430 ef5b1b5a Juanjo
        c = 1024;
1431
    pred_dc = 1024;
1432
    /* just DC prediction */
1433
    if (a != 1024 && c != 1024)
1434
        pred_dc = (a + c) >> 1;
1435
    else if (a != 1024)
1436
        pred_dc = a;
1437
    else
1438
        pred_dc = c;
1439
    
1440
    /* we assume pred is positive */
1441
    //pred_dc = (pred_dc + (scale >> 1)) / scale;
1442
    *dc_val_ptr = &dc_val[x + y * wrap];
1443
    return pred_dc;
1444 de6d9b64 Fabrice Bellard
}
1445
1446 5c91a675 Zdenek Kabelac
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1447 d140623f Juanjo
{
1448 9e15ad28 Juanjo
    int x, y, wrap, a, c, pred_dc, scale, i;
1449 0c1a9eda Zdenek Kabelac
    int16_t *dc_val, *ac_val, *ac_val1;
1450 d140623f Juanjo
1451
    /* find prediction */
1452
    if (n < 4) {
1453
        x = 2 * s->mb_x + 1 + (n & 1);
1454 68b94c35 Michael Niedermayer
        y = 2 * s->mb_y + 1 + (n>> 1);
1455 d140623f Juanjo
        wrap = s->mb_width * 2 + 2;
1456
        dc_val = s->dc_val[0];
1457 9e15ad28 Juanjo
        ac_val = s->ac_val[0][0];
1458 d140623f Juanjo
        scale = s->y_dc_scale;
1459
    } else {
1460
        x = s->mb_x + 1;
1461
        y = s->mb_y + 1;
1462
        wrap = s->mb_width + 2;
1463
        dc_val = s->dc_val[n - 4 + 1];
1464 9e15ad28 Juanjo
        ac_val = s->ac_val[n - 4 + 1][0];
1465 d140623f Juanjo
        scale = s->c_dc_scale;
1466
    }
1467 9e15ad28 Juanjo
    
1468
    ac_val += ((y) * wrap + (x)) * 16;
1469
    ac_val1 = ac_val;
1470
    
1471 d140623f Juanjo
    /* B C
1472
     * A X 
1473
     */
1474
    a = dc_val[(x - 1) + (y) * wrap];
1475
    c = dc_val[(x) + (y - 1) * wrap];
1476
    
1477 ef5b1b5a Juanjo
    /* No prediction outside GOB boundary */
1478 68b94c35 Michael Niedermayer
    if(s->first_slice_line && n!=3){
1479
        if(n!=2) c= 1024;
1480
        if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1481
    }
1482
    
1483 d140623f Juanjo
    if (s->ac_pred) {
1484 68b94c35 Michael Niedermayer
        pred_dc = 1024;
1485 d140623f Juanjo
        if (s->h263_aic_dir) {
1486
            /* left prediction */
1487 9e15ad28 Juanjo
            if (a != 1024) {
1488
                ac_val -= 16;
1489
                for(i=1;i<8;i++) {
1490 b0368839 Michael Niedermayer
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1491 9e15ad28 Juanjo
                }
1492
                pred_dc = a;
1493 d140623f Juanjo
            }
1494
        } else {
1495
            /* top prediction */
1496 9e15ad28 Juanjo
            if (c != 1024) {
1497
                ac_val -= 16 * wrap;
1498
                for(i=1;i<8;i++) {
1499 b0368839 Michael Niedermayer
                    block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1500 9e15ad28 Juanjo
                }
1501
                pred_dc = c;
1502 d140623f Juanjo
            }
1503
        }
1504 9e15ad28 Juanjo
    } else {
1505
        /* just DC prediction */
1506
        if (a != 1024 && c != 1024)
1507
            pred_dc = (a + c) >> 1;
1508
        else if (a != 1024)
1509
            pred_dc = a;
1510
        else
1511
            pred_dc = c;
1512 d140623f Juanjo
    }
1513 9e15ad28 Juanjo
    
1514
    /* we assume pred is positive */
1515
    block[0]=block[0]*scale + pred_dc;
1516
    
1517
    if (block[0] < 0)
1518
        block[0] = 0;
1519 68b94c35 Michael Niedermayer
    else 
1520
        block[0] |= 1;
1521 9e15ad28 Juanjo
    
1522
    /* Update AC/DC tables */
1523
    dc_val[(x) + (y) * wrap] = block[0];
1524
    
1525 d140623f Juanjo
    /* left copy */
1526
    for(i=1;i<8;i++)
1527 b0368839 Michael Niedermayer
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1528 d140623f Juanjo
    /* top copy */
1529
    for(i=1;i<8;i++)
1530 b0368839 Michael Niedermayer
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1531 d140623f Juanjo
}
1532
1533 0c1a9eda Zdenek Kabelac
int16_t *h263_pred_motion(MpegEncContext * s, int block, 
1534 de6d9b64 Fabrice Bellard
                        int *px, int *py)
1535
{
1536 4278e7a6 Michael Niedermayer
    int xy, wrap;
1537 0c1a9eda Zdenek Kabelac
    int16_t *A, *B, *C, *mot_val;
1538 49c9325f Michael Niedermayer
    static const int off[4]= {2, 1, 1, -1};
1539 de6d9b64 Fabrice Bellard
1540 4278e7a6 Michael Niedermayer
    wrap = s->block_wrap[0];
1541
    xy = s->block_index[block];
1542 de6d9b64 Fabrice Bellard
1543 8d7ec294 Wolfgang Hesseler
    mot_val = s->current_picture.motion_val[0][xy];
1544 de6d9b64 Fabrice Bellard
1545 8d7ec294 Wolfgang Hesseler
    A = s->current_picture.motion_val[0][xy - 1];
1546 92073d01 Michael Niedermayer
    /* special case for first (slice) line */
1547 4d2858de Michael Niedermayer
    if (s->first_slice_line && block<3) {
1548 92073d01 Michael Niedermayer
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1549
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1550
        if(block==0){ //most common case
1551
            if(s->mb_x  == s->resync_mb_x){ //rare
1552
                *px= *py = 0;
1553 e1f03acc Michael Niedermayer
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1554 8d7ec294 Wolfgang Hesseler
                C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1555 92073d01 Michael Niedermayer
                if(s->mb_x==0){
1556
                    *px = C[0];
1557
                    *py = C[1];
1558
                }else{
1559
                    *px = mid_pred(A[0], 0, C[0]);
1560
                    *py = mid_pred(A[1], 0, C[1]);
1561
                }
1562
            }else{
1563
                *px = A[0];
1564
                *py = A[1];
1565
            }
1566
        }else if(block==1){
1567 e1f03acc Michael Niedermayer
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1568 8d7ec294 Wolfgang Hesseler
                C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1569 92073d01 Michael Niedermayer
                *px = mid_pred(A[0], 0, C[0]);
1570
                *py = mid_pred(A[1], 0, C[1]);
1571
            }else{
1572
                *px = A[0];
1573
                *py = A[1];
1574
            }
1575
        }else{ /* block==2*/
1576 8d7ec294 Wolfgang Hesseler
            B = s->current_picture.motion_val[0][xy - wrap];
1577
            C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1578 92073d01 Michael Niedermayer
            if(s->mb_x == s->resync_mb_x) //rare
1579
                A[0]=A[1]=0;
1580
    
1581
            *px = mid_pred(A[0], B[0], C[0]);
1582
            *py = mid_pred(A[1], B[1], C[1]);
1583
        }
1584 de6d9b64 Fabrice Bellard
    } else {
1585 8d7ec294 Wolfgang Hesseler
        B = s->current_picture.motion_val[0][xy - wrap];
1586
        C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1587 de6d9b64 Fabrice Bellard
        *px = mid_pred(A[0], B[0], C[0]);
1588
        *py = mid_pred(A[1], B[1], C[1]);
1589
    }
1590
    return mot_val;
1591
}
1592
1593 b40cd4e0 Michael Niedermayer
// identical to above but with s->current_picture->motion_val, the above one will be removed, and this renamed to it
1594
int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir,
1595
                        int *px, int *py)
1596
{
1597
    int xy, wrap;
1598
    int16_t *A, *B, *C, (*mot_val)[2];
1599
    static const int off[4]= {2, 1, 1, -1};
1600
1601
    wrap = s->b8_stride;
1602 8135f8df Michael Niedermayer
    xy = 2*(s->mb_x + s->mb_y * wrap);
1603 b40cd4e0 Michael Niedermayer
1604 8135f8df Michael Niedermayer
    mot_val = s->current_picture.motion_val[dir] + xy;
1605 b40cd4e0 Michael Niedermayer
1606
    A = mot_val[ - 1];
1607
    /* special case for first (slice) line */
1608
    if (s->first_slice_line && block<3) {
1609
        // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1610
        // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1611
        if(block==0){ //most common case
1612
            if(s->mb_x  == s->resync_mb_x){ //rare
1613
                *px= *py = 0;
1614
            }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1615
                C = mot_val[off[block] - wrap];
1616
                if(s->mb_x==0){
1617
                    *px = C[0];
1618
                    *py = C[1];
1619
                }else{
1620
                    *px = mid_pred(A[0], 0, C[0]);
1621
                    *py = mid_pred(A[1], 0, C[1]);
1622
                }
1623
            }else{
1624
                *px = A[0];
1625
                *py = A[1];
1626
            }
1627
        }else if(block==1){
1628
            if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1629
                C = mot_val[off[block] - wrap];
1630
                *px = mid_pred(A[0], 0, C[0]);
1631
                *py = mid_pred(A[1], 0, C[1]);
1632
            }else{
1633
                *px = A[0];
1634
                *py = A[1];
1635
            }
1636
        }else{ /* block==2*/
1637
            B = mot_val[ - wrap];
1638
            C = mot_val[off[block] - wrap];
1639
            if(s->mb_x == s->resync_mb_x) //rare
1640
                A[0]=A[1]=0;
1641
    
1642
            *px = mid_pred(A[0], B[0], C[0]);
1643
            *py = mid_pred(A[1], B[1], C[1]);
1644
        }
1645
    } else {
1646
        B = mot_val[ - wrap];
1647
        C = mot_val[off[block] - wrap];
1648
        *px = mid_pred(A[0], B[0], C[0]);
1649
        *py = mid_pred(A[1], B[1], C[1]);
1650
    }
1651
    return *mot_val;
1652
}
1653
1654 bbed9259 Michael Niedermayer
#ifdef CONFIG_ENCODERS
1655 9dbcbd92 Michael Niedermayer
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1656 de6d9b64 Fabrice Bellard
{
1657 a9c68306 Michael Niedermayer
    int range, l, bit_size, sign, code, bits;
1658 de6d9b64 Fabrice Bellard
1659
    if (val == 0) {
1660
        /* zero vector */
1661
        code = 0;
1662
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1663
    } else {
1664 9dbcbd92 Michael Niedermayer
        bit_size = f_code - 1;
1665 de6d9b64 Fabrice Bellard
        range = 1 << bit_size;
1666
        /* modulo encoding */
1667
        l = range * 32;
1668 a9c68306 Michael Niedermayer
#if 1
1669
        val+= l;
1670
        val&= 2*l-1;
1671
        val-= l;
1672
        sign = val>>31;
1673
        val= (val^sign)-sign;
1674
        sign&=1;
1675
#else
1676 de6d9b64 Fabrice Bellard
        if (val < -l) {
1677 a9c68306 Michael Niedermayer
            val += 2*l;
1678 de6d9b64 Fabrice Bellard
        } else if (val >= l) {
1679 a9c68306 Michael Niedermayer
            val -= 2*l;
1680 de6d9b64 Fabrice Bellard
        }
1681 a9c68306 Michael Niedermayer
1682 c5d309f2 Michael Niedermayer
        assert(val>=-l && val<l);
1683 de6d9b64 Fabrice Bellard
1684
        if (val >= 0) {
1685
            sign = 0;
1686
        } else {
1687
            val = -val;
1688
            sign = 1;
1689
        }
1690 a9c68306 Michael Niedermayer
#endif
1691 3bf43d42 Michael Niedermayer
        val--;
1692
        code = (val >> bit_size) + 1;
1693
        bits = val & (range - 1);
1694 de6d9b64 Fabrice Bellard
1695
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1696
        if (bit_size > 0) {
1697
            put_bits(&s->pb, bit_size, bits);
1698
        }
1699
    }
1700 3a3d3a42 Michael Niedermayer
1701 de6d9b64 Fabrice Bellard
}
1702
1703 6dbd39fe Juanjo
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1704
static void h263p_encode_umotion(MpegEncContext * s, int val)
1705
{
1706
    short sval = 0; 
1707
    short i = 0;
1708
    short n_bits = 0;
1709
    short temp_val;
1710
    int code = 0;
1711
    int tcode;
1712
    
1713
    if ( val == 0)
1714
        put_bits(&s->pb, 1, 1);
1715
    else if (val == 1)
1716
        put_bits(&s->pb, 3, 0);
1717
    else if (val == -1)
1718
        put_bits(&s->pb, 3, 2);
1719
    else {
1720
        
1721
        sval = ((val < 0) ? (short)(-val):(short)val);
1722
        temp_val = sval;
1723
        
1724
        while (temp_val != 0) {
1725
            temp_val = temp_val >> 1;
1726
            n_bits++;
1727
        }
1728
        
1729
        i = n_bits - 1;
1730
        while (i > 0) {
1731
            tcode = (sval & (1 << (i-1))) >> (i-1);
1732
            tcode = (tcode << 1) | 1;
1733
            code = (code << 2) | tcode;
1734
            i--;
1735
        }
1736
        code = ((code << 1) | (val < 0)) << 1;
1737
        put_bits(&s->pb, (2*n_bits)+1, code);
1738
        //printf("\nVal = %d\tCode = %d", sval, code);
1739
    }
1740
}
1741
1742 45870f57 Michael Niedermayer
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1743
{
1744
    int f_code;
1745
    int mv;
1746 bbed9259 Michael Niedermayer
    
1747
    if(mv_penalty==NULL)
1748 30952237 Michael Niedermayer
        mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1749 bbed9259 Michael Niedermayer
    
1750 45870f57 Michael Niedermayer
    for(f_code=1; f_code<=MAX_FCODE; f_code++){
1751
        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1752
            int len;
1753
1754
            if(mv==0) len= mvtab[0][1];
1755
            else{
1756
                int val, bit_size, range, code;
1757
1758
                bit_size = s->f_code - 1;
1759
                range = 1 << bit_size;
1760
1761
                val=mv;
1762
                if (val < 0) 
1763
                    val = -val;
1764
                val--;
1765
                code = (val >> bit_size) + 1;
1766
                if(code<33){
1767
                    len= mvtab[code][1] + 1 + bit_size;
1768
                }else{
1769
                    len= mvtab[32][1] + 2 + bit_size;
1770
                }
1771
            }
1772
1773
            mv_penalty[f_code][mv+MAX_MV]= len;
1774
        }
1775
    }
1776
1777
    for(f_code=MAX_FCODE; f_code>0; f_code--){
1778
        for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1779
            fcode_tab[mv+MAX_MV]= f_code;
1780
        }
1781
    }
1782 9d2a0355 Michael Niedermayer
1783
    for(mv=0; mv<MAX_MV*2+1; mv++){
1784
        umv_fcode_tab[mv]= 1;
1785
    }
1786 45870f57 Michael Niedermayer
}
1787 bbed9259 Michael Niedermayer
#endif
1788 45870f57 Michael Niedermayer
1789 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
1790
1791 20695ec9 Falk H├╝ffner
static void init_uni_dc_tab(void)
1792 2a164b25 Michael Niedermayer
{
1793
    int level, uni_code, uni_len;
1794
1795 3bf43d42 Michael Niedermayer
    for(level=-256; level<256; level++){
1796 2a164b25 Michael Niedermayer
        int size, v, l;
1797
        /* find number of bits */
1798
        size = 0;
1799
        v = abs(level);
1800
        while (v) {
1801
            v >>= 1;
1802
            size++;
1803
        }
1804
1805
        if (level < 0)
1806
            l= (-level) ^ ((1 << size) - 1);
1807
        else
1808
            l= level;
1809
1810
        /* luminance */
1811
        uni_code= DCtab_lum[size][0];
1812
        uni_len = DCtab_lum[size][1];
1813
1814
        if (size > 0) {
1815
            uni_code<<=size; uni_code|=l;
1816
            uni_len+=size;
1817
            if (size > 8){
1818
                uni_code<<=1; uni_code|=1;
1819
                uni_len++;
1820
            }
1821
        }
1822 67725183 Michael Niedermayer
        uni_DCtab_lum_bits[level+256]= uni_code;
1823
        uni_DCtab_lum_len [level+256]= uni_len;
1824 2a164b25 Michael Niedermayer
1825
        /* chrominance */
1826
        uni_code= DCtab_chrom[size][0];
1827
        uni_len = DCtab_chrom[size][1];
1828
        
1829
        if (size > 0) {
1830
            uni_code<<=size; uni_code|=l;
1831
            uni_len+=size;
1832
            if (size > 8){
1833
                uni_code<<=1; uni_code|=1;
1834
                uni_len++;
1835
            }
1836
        }
1837 67725183 Michael Niedermayer
        uni_DCtab_chrom_bits[level+256]= uni_code;
1838
        uni_DCtab_chrom_len [level+256]= uni_len;
1839 2a164b25 Michael Niedermayer
1840
    }
1841
}
1842
1843 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
1844
1845 bbed9259 Michael Niedermayer
#ifdef CONFIG_ENCODERS
1846 0c1a9eda Zdenek Kabelac
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1847 3db48188 Michael Niedermayer
    int slevel, run, last;
1848
    
1849
    assert(MAX_LEVEL >= 64);
1850
    assert(MAX_RUN   >= 63);
1851
1852
    for(slevel=-64; slevel<64; slevel++){
1853
        if(slevel==0) continue;
1854
        for(run=0; run<64; run++){
1855
            for(last=0; last<=1; last++){
1856
                const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1857
                int level= slevel < 0 ? -slevel : slevel;
1858
                int sign= slevel < 0 ? 1 : 0;
1859
                int bits, len, code;
1860
                int level1, run1;
1861
                
1862
                len_tab[index]= 100;
1863
                     
1864
                /* ESC0 */
1865
                code= get_rl_index(rl, last, run, level);
1866
                bits= rl->table_vlc[code][0];
1867
                len=  rl->table_vlc[code][1];
1868
                bits=bits*2+sign; len++;
1869
                
1870
                if(code!=rl->n && len < len_tab[index]){
1871
                    bits_tab[index]= bits;
1872
                    len_tab [index]= len;
1873
                }
1874
#if 1
1875
                /* ESC1 */
1876
                bits= rl->table_vlc[rl->n][0];
1877
                len=  rl->table_vlc[rl->n][1];
1878
                bits=bits*2;    len++; //esc1
1879
                level1= level - rl->max_level[last][run];
1880
                if(level1>0){
1881
                    code= get_rl_index(rl, last, run, level1);
1882
                    bits<<= rl->table_vlc[code][1];
1883
                    len  += rl->table_vlc[code][1];
1884
                    bits += rl->table_vlc[code][0];
1885
                    bits=bits*2+sign; len++;
1886
                
1887
                    if(code!=rl->n && len < len_tab[index]){
1888
                        bits_tab[index]= bits;
1889
                        len_tab [index]= len;
1890
                    }
1891
                }
1892
#endif 
1893
#if 1
1894
                /* ESC2 */
1895
                bits= rl->table_vlc[rl->n][0];
1896
                len=  rl->table_vlc[rl->n][1];
1897
                bits=bits*4+2;    len+=2; //esc2
1898
                run1 = run - rl->max_run[last][level] - 1;
1899
                if(run1>=0){
1900
                    code= get_rl_index(rl, last, run1, level);
1901
                    bits<<= rl->table_vlc[code][1];
1902
                    len  += rl->table_vlc[code][1];
1903
                    bits += rl->table_vlc[code][0];
1904
                    bits=bits*2+sign; len++;
1905
                
1906
                    if(code!=rl->n && len < len_tab[index]){
1907
                        bits_tab[index]= bits;
1908
                        len_tab [index]= len;
1909
                    }
1910
                }
1911
#endif           
1912
                /* ESC3 */        
1913
                bits= rl->table_vlc[rl->n][0];
1914
                len = rl->table_vlc[rl->n][1];
1915
                bits=bits*4+3;    len+=2; //esc3
1916
                bits=bits*2+last; len++;
1917
                bits=bits*64+run; len+=6;
1918
                bits=bits*2+1;    len++;  //marker
1919
                bits=bits*4096+(slevel&0xfff); len+=12;
1920
                bits=bits*2+1;    len++;  //marker
1921
                
1922
                if(len < len_tab[index]){
1923
                    bits_tab[index]= bits;
1924
                    len_tab [index]= len;
1925
                }
1926
            }
1927
        }
1928
    }
1929
}
1930
1931 45870f57 Michael Niedermayer
void h263_encode_init(MpegEncContext *s)
1932 de6d9b64 Fabrice Bellard
{
1933
    static int done = 0;
1934
1935
    if (!done) {
1936
        done = 1;
1937 2a164b25 Michael Niedermayer
1938
        init_uni_dc_tab();
1939
1940 de6d9b64 Fabrice Bellard
        init_rl(&rl_inter);
1941
        init_rl(&rl_intra);
1942 ef5b1b5a Juanjo
        init_rl(&rl_intra_aic);
1943 3db48188 Michael Niedermayer
        
1944
        init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1945
        init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1946 45870f57 Michael Niedermayer
1947
        init_mv_penalty_and_fcode(s);
1948 de6d9b64 Fabrice Bellard
    }
1949 1457ab52 Michael Niedermayer
    s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1950 45870f57 Michael Niedermayer
    
1951 9d2a0355 Michael Niedermayer
    // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1952 d7e9533a Michael Niedermayer
    switch(s->codec_id){
1953
    case CODEC_ID_MPEG4:
1954
        s->fcode_tab= fcode_tab;
1955
        s->min_qcoeff= -2048;
1956
        s->max_qcoeff=  2047;
1957 477ab036 Michael Niedermayer
        s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1958
        s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1959
        s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1960
        s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1961 67725183 Michael Niedermayer
        s->luma_dc_vlc_length= uni_DCtab_lum_len;
1962
        s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1963 477ab036 Michael Niedermayer
        s->ac_esc_length= 7+2+1+6+1+12+1;
1964 9c3d33d6 Michael Niedermayer
        s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
1965
        s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1966
1967 22ddd60b Michael Niedermayer
        if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1968 8b76418a Michael Niedermayer
1969 22ddd60b Michael Niedermayer
            s->avctx->extradata= av_malloc(1024);
1970 ed7debda Alex Beregszaszi
            init_put_bits(&s->pb, s->avctx->extradata, 1024);
1971 22ddd60b Michael Niedermayer
            
1972
            mpeg4_encode_visual_object_header(s);
1973
            mpeg4_encode_vol_header(s, 0, 0);
1974
1975
//            ff_mpeg4_stuffing(&s->pb); ?
1976
            flush_put_bits(&s->pb);
1977 fe455f33 Alex Beregszaszi
            s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1978 22ddd60b Michael Niedermayer
        }
1979
        
1980 d7e9533a Michael Niedermayer
        break;
1981
    case CODEC_ID_H263P:
1982 fb079883 Michael Niedermayer
        if(s->umvplus)
1983
            s->fcode_tab= umv_fcode_tab;
1984
        if(s->modified_quant){
1985
            s->min_qcoeff= -2047;
1986
            s->max_qcoeff=  2047;
1987
        }else{
1988
            s->min_qcoeff= -127;
1989
            s->max_qcoeff=  127;
1990
        }
1991 d7e9533a Michael Niedermayer
        break;
1992 8f8402e4 Michael Niedermayer
        //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
1993 d4f5d74a Garrick Meeker
    case CODEC_ID_FLV1:
1994
        if (s->h263_flv > 1) {
1995
            s->min_qcoeff= -1023;
1996
            s->max_qcoeff=  1023;
1997
        } else {
1998
            s->min_qcoeff= -127;
1999
            s->max_qcoeff=  127;
2000
        }
2001
        s->y_dc_scale_table=
2002
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2003
        break;
2004 d7e9533a Michael Niedermayer
    default: //nothing needed default table allready set in mpegvideo.c
2005 e51d6d27 Michael Niedermayer
        s->min_qcoeff= -127;
2006 d7e9533a Michael Niedermayer
        s->max_qcoeff=  127;
2007 8f8402e4 Michael Niedermayer
        s->y_dc_scale_table=
2008
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2009 d7e9533a Michael Niedermayer
    }
2010 de6d9b64 Fabrice Bellard
}
2011
2012 2ba8f6b8 Michael Niedermayer
/**
2013
 * encodes a 8x8 block.
2014
 * @param block the 8x8 block
2015
 * @param n block index (0-3 are luma, 4-5 are chroma)
2016
 */
2017 de6d9b64 Fabrice Bellard
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2018
{
2019 ef5b1b5a Juanjo
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2020
    RLTable *rl;
2021 de6d9b64 Fabrice Bellard
2022 ef5b1b5a Juanjo
    rl = &rl_inter;
2023
    if (s->mb_intra && !s->h263_aic) {
2024 81401c1f Juanjo
        /* DC coef */
2025 e51d6d27 Michael Niedermayer
        level = block[0];
2026 de6d9b64 Fabrice Bellard
        /* 255 cannot be represented, so we clamp */
2027
        if (level > 254) {
2028
            level = 254;
2029
            block[0] = 254;
2030
        }
2031 81401c1f Juanjo
        /* 0 cannot be represented also */
2032 e51d6d27 Michael Niedermayer
        else if (level < 1) {
2033 81401c1f Juanjo
            level = 1;
2034
            block[0] = 1;
2035
        }
2036 17938602 Michael Niedermayer
        if (level == 128) //FIXME check rv10
2037 e51d6d27 Michael Niedermayer
            put_bits(&s->pb, 8, 0xff);
2038
        else
2039 65a24d0b Michael Niedermayer
            put_bits(&s->pb, 8, level);
2040 e51d6d27 Michael Niedermayer
        i = 1;
2041 de6d9b64 Fabrice Bellard
    } else {
2042 e51d6d27 Michael Niedermayer
        i = 0;
2043
        if (s->h263_aic && s->mb_intra)
2044
            rl = &rl_intra_aic;
2045 dba019da Michael Niedermayer
            
2046
        if(s->alt_inter_vlc && !s->mb_intra){
2047
            int aic_vlc_bits=0;
2048
            int inter_vlc_bits=0;
2049
            int wrong_pos=-1;
2050
            int aic_code;
2051
            
2052
            last_index = s->block_last_index[n];
2053
            last_non_zero = i - 1;
2054
            for (; i <= last_index; i++) {
2055
                j = s->intra_scantable.permutated[i];
2056
                level = block[j];
2057
                if (level) {
2058
                    run = i - last_non_zero - 1;
2059
                    last = (i == last_index);
2060 ecfc44e6 Michael Niedermayer
                    
2061
                    if(level<0) level= -level;
2062 dba019da Michael Niedermayer
                
2063
                    code = get_rl_index(rl, last, run, level);
2064
                    aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2065
                    inter_vlc_bits += rl->table_vlc[code][1]+1;
2066
                    aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2067
2068
                    if (code == rl->n) {
2069 ecfc44e6 Michael Niedermayer
                        inter_vlc_bits += 1+6+8-1;
2070 dba019da Michael Niedermayer
                    }                
2071
                    if (aic_code == rl_intra_aic.n) {
2072 ecfc44e6 Michael Niedermayer
                        aic_vlc_bits += 1+6+8-1;
2073 dba019da Michael Niedermayer
                        wrong_pos += run + 1;
2074
                    }else
2075
                        wrong_pos += wrong_run[aic_code];
2076
                    last_non_zero = i;
2077
                }    
2078
            }
2079
            i = 0;
2080
            if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2081
                rl = &rl_intra_aic;
2082
        }
2083 de6d9b64 Fabrice Bellard
    }
2084 ef5b1b5a Juanjo
   
2085 de6d9b64 Fabrice Bellard
    /* AC coefs */
2086
    last_index = s->block_last_index[n];
2087
    last_non_zero = i - 1;
2088
    for (; i <= last_index; i++) {
2089 2ad1516a Michael Niedermayer
        j = s->intra_scantable.permutated[i];
2090 ef5b1b5a Juanjo
        level = block[j];
2091
        if (level) {
2092
            run = i - last_non_zero - 1;
2093
            last = (i == last_index);
2094
            sign = 0;
2095
            slevel = level;
2096
            if (level < 0) {
2097
                sign = 1;
2098
                level = -level;
2099
            }
2100 de6d9b64 Fabrice Bellard
            code = get_rl_index(rl, last, run, level);
2101
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2102
            if (code == rl->n) {
2103 44a2950f Michael Niedermayer
              if(s->h263_flv <= 1){
2104 de6d9b64 Fabrice Bellard
                put_bits(&s->pb, 1, last);
2105
                put_bits(&s->pb, 6, run);
2106 e51d6d27 Michael Niedermayer
                
2107
                assert(slevel != 0);
2108
2109 65a24d0b Michael Niedermayer
                if(level < 128) 
2110 e51d6d27 Michael Niedermayer
                    put_bits(&s->pb, 8, slevel & 0xff);
2111
                else{
2112
                    put_bits(&s->pb, 8, 128);
2113
                    put_bits(&s->pb, 5, slevel & 0x1f);
2114
                    put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2115
                }
2116 44a2950f Michael Niedermayer
              }else{
2117 65a24d0b Michael Niedermayer
                if(level < 64) { // 7-bit level
2118 44a2950f Michael Niedermayer
                        put_bits(&s->pb, 1, 0);
2119
                        put_bits(&s->pb, 1, last);
2120
                        put_bits(&s->pb, 6, run);
2121
2122
                        put_bits(&s->pb, 7, slevel & 0x7f);
2123
                    } else {
2124
                        /* 11-bit level */
2125
                        put_bits(&s->pb, 1, 1);
2126
                        put_bits(&s->pb, 1, last);
2127
                        put_bits(&s->pb, 6, run);
2128
2129
                        put_bits(&s->pb, 11, slevel & 0x7ff);
2130
                    }
2131
              }
2132 d4f5d74a Garrick Meeker
            } else {
2133
                put_bits(&s->pb, 1, sign);
2134
            }
2135
            last_non_zero = i;
2136
        }
2137
    }
2138
}
2139 bbed9259 Michael Niedermayer
#endif
2140 de6d9b64 Fabrice Bellard
2141 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
2142
2143 de6d9b64 Fabrice Bellard
/***************************************************/
2144 4d2858de Michael Niedermayer
/**
2145
 * add mpeg4 stuffing bits (01...1)
2146
 */
2147 92073d01 Michael Niedermayer
void ff_mpeg4_stuffing(PutBitContext * pbc)
2148 6f91bcd1 Michael Niedermayer
{
2149
    int length;
2150
    put_bits(pbc, 1, 0);
2151 fe455f33 Alex Beregszaszi
    length= (-put_bits_count(pbc))&7;
2152 92073d01 Michael Niedermayer
    if(length) put_bits(pbc, length, (1<<length)-1);
2153 6f91bcd1 Michael Niedermayer
}
2154
2155 91029be7 Michael Niedermayer
/* must be called before writing the header */
2156
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2157
    int time_div, time_mod;
2158
2159 9740beff Michael Niedermayer
    assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2160
    s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2161 e51f4948 Michael Niedermayer
2162 91029be7 Michael Niedermayer
    time_div= s->time/s->time_increment_resolution;
2163
    time_mod= s->time%s->time_increment_resolution;
2164
2165
    if(s->pict_type==B_TYPE){
2166 bea669e5 Michael Niedermayer
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2167 91029be7 Michael Niedermayer
    }else{
2168
        s->last_time_base= s->time_base;
2169
        s->time_base= time_div;
2170
        s->pp_time= s->time - s->last_non_b_time;
2171
        s->last_non_b_time= s->time;
2172
    }
2173
}
2174
2175 41773b73 Michael Niedermayer
static void mpeg4_encode_gop_header(MpegEncContext * s){
2176
    int hours, minutes, seconds;
2177 6ff6cff2 Michael Niedermayer
    int64_t time;
2178 41773b73 Michael Niedermayer
    
2179
    put_bits(&s->pb, 16, 0);
2180
    put_bits(&s->pb, 16, GOP_STARTCODE);
2181
    
2182 9740beff Michael Niedermayer
    time= s->current_picture_ptr->pts;
2183
    if(s->reordered_input_picture[1])
2184
        time= FFMIN(time, s->reordered_input_picture[1]->pts);
2185
    time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2186 6ff6cff2 Michael Niedermayer
2187
    seconds= time/s->time_increment_resolution;
2188 41773b73 Michael Niedermayer
    minutes= seconds/60; seconds %= 60;
2189
    hours= minutes/60; minutes %= 60;
2190
    hours%=24;
2191
2192
    put_bits(&s->pb, 5, hours);
2193
    put_bits(&s->pb, 6, minutes);
2194
    put_bits(&s->pb, 1, 1);
2195
    put_bits(&s->pb, 6, seconds);
2196
    
2197 11a8a71d Michael Niedermayer
    put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
2198 41773b73 Michael Niedermayer
    put_bits(&s->pb, 1, 0); //broken link == NO
2199 11a8a71d Michael Niedermayer
    
2200 6ff6cff2 Michael Niedermayer
    s->last_time_base= time / s->time_increment_resolution; 
2201 41773b73 Michael Niedermayer
2202
    ff_mpeg4_stuffing(&s->pb);
2203
}
2204
2205
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2206
    int profile_and_level_indication;
2207
    int vo_ver_id;
2208
    
2209
    if(s->max_b_frames || s->quarter_sample){
2210
        profile_and_level_indication= 0xF1; // adv simple level 1
2211
        vo_ver_id= 5;
2212
    }else{
2213
        profile_and_level_indication= 0x01; // simple level 1
2214
        vo_ver_id= 1;
2215
    }
2216
    //FIXME levels
2217
2218
    put_bits(&s->pb, 16, 0);
2219
    put_bits(&s->pb, 16, VOS_STARTCODE);
2220 3f6f76af Michael Niedermayer
2221 41773b73 Michael Niedermayer
    put_bits(&s->pb, 8, profile_and_level_indication);
2222 3f6f76af Michael Niedermayer
2223 41773b73 Michael Niedermayer
    put_bits(&s->pb, 16, 0);
2224
    put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2225
    
2226
    put_bits(&s->pb, 1, 1);
2227
        put_bits(&s->pb, 4, vo_ver_id);
2228
        put_bits(&s->pb, 3, 1); //priority
2229
 
2230
    put_bits(&s->pb, 4, 1); //visual obj type== video obj
2231
    
2232
    put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2233
2234
    ff_mpeg4_stuffing(&s->pb);
2235
}
2236
2237
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2238 de6d9b64 Fabrice Bellard
{
2239 41773b73 Michael Niedermayer
    int vo_ver_id;
2240 1ff662cc Michael Niedermayer
2241 41773b73 Michael Niedermayer
    if(s->max_b_frames || s->quarter_sample){
2242
        vo_ver_id= 5;
2243 f8af5cb5 Michael Niedermayer
        s->vo_type= ADV_SIMPLE_VO_TYPE;
2244
    }else{
2245 41773b73 Michael Niedermayer
        vo_ver_id= 1;
2246 f8af5cb5 Michael Niedermayer
        s->vo_type= SIMPLE_VO_TYPE;
2247
    }
2248 1ff662cc Michael Niedermayer
2249 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 16, 0);
2250 41773b73 Michael Niedermayer
    put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2251 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 16, 0);
2252 41773b73 Michael Niedermayer
    put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2253 10cd5815 Michael Niedermayer
2254
    put_bits(&s->pb, 1, 0);                /* random access vol */
2255 1ff662cc Michael Niedermayer
    put_bits(&s->pb, 8, s->vo_type);        /* video obj type indication */
2256 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 1, 1);                /* is obj layer id= yes */
2257
      put_bits(&s->pb, 4, vo_ver_id);        /* is obj layer ver id */
2258
      put_bits(&s->pb, 3, 1);                /* is obj layer priority */
2259 5d3cea3a Michael Niedermayer
    
2260 5ff85f1d Michael Niedermayer
    aspect_to_info(s, s->avctx->sample_aspect_ratio);
2261 5d3cea3a Michael Niedermayer
2262
    put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2263 5ff85f1d Michael Niedermayer
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2264
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2265
        put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2266 050fe8ba Alex Beregszaszi
    }
2267 1ff662cc Michael Niedermayer
2268
    if(s->low_delay){
2269
        put_bits(&s->pb, 1, 1);                /* vol control parameters= yes */
2270 1c2a8c7f Michael Niedermayer
        put_bits(&s->pb, 2, 1);                /* chroma format YUV 420/YV12 */
2271 1ff662cc Michael Niedermayer
        put_bits(&s->pb, 1, s->low_delay);
2272
        put_bits(&s->pb, 1, 0);                /* vbv parameters= no */
2273
    }else{
2274
        put_bits(&s->pb, 1, 0);                /* vol control parameters= no */
2275
    }
2276
2277 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 2, RECT_SHAPE);        /* vol shape= rectangle */
2278
    put_bits(&s->pb, 1, 1);                /* marker bit */
2279 9dbcbd92 Michael Niedermayer
    
2280
    put_bits(&s->pb, 16, s->time_increment_resolution);
2281 10cd5815 Michael Niedermayer
    if (s->time_increment_bits < 1)
2282
        s->time_increment_bits = 1;
2283
    put_bits(&s->pb, 1, 1);                /* marker bit */
2284
    put_bits(&s->pb, 1, 0);                /* fixed vop rate=no */
2285
    put_bits(&s->pb, 1, 1);                /* marker bit */
2286
    put_bits(&s->pb, 13, s->width);        /* vol width */
2287
    put_bits(&s->pb, 1, 1);                /* marker bit */
2288
    put_bits(&s->pb, 13, s->height);        /* vol height */
2289
    put_bits(&s->pb, 1, 1);                /* marker bit */
2290 fcb48651 Michael Niedermayer
    put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2291 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 1, 1);                /* obmc disable */
2292
    if (vo_ver_id == 1) {
2293 9c3d33d6 Michael Niedermayer
        put_bits(&s->pb, 1, s->vol_sprite_usage);                /* sprite enable */
2294 41773b73 Michael Niedermayer
    }else{
2295 9c3d33d6 Michael Niedermayer
        put_bits(&s->pb, 2, s->vol_sprite_usage);                /* sprite enable */
2296 10cd5815 Michael Niedermayer
    }
2297 4d2858de Michael Niedermayer
    
2298
    put_bits(&s->pb, 1, 0);                /* not 8 bit == false */
2299 87f8cab4 Michael Niedermayer
    put_bits(&s->pb, 1, s->mpeg_quant);        /* quant type= (0=h263 style)*/
2300 d6eb3c50 Michael Niedermayer
2301
    if(s->mpeg_quant){
2302
        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2303
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2304
    }
2305 87f8cab4 Michael Niedermayer
2306 10cd5815 Michael Niedermayer
    if (vo_ver_id != 1)
2307 1457ab52 Michael Niedermayer
        put_bits(&s->pb, 1, s->quarter_sample);
2308 10cd5815 Michael Niedermayer
    put_bits(&s->pb, 1, 1);                /* complexity estimation disable */
2309 92073d01 Michael Niedermayer
    s->resync_marker= s->rtp_mode;
2310
    put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2311
    put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2312
    if(s->data_partitioning){
2313
        put_bits(&s->pb, 1, 0);                /* no rvlc */
2314
    }
2315
2316 10cd5815 Michael Niedermayer
    if (vo_ver_id != 1){
2317
        put_bits(&s->pb, 1, 0);                /* newpred */
2318
        put_bits(&s->pb, 1, 0);                /* reduced res vop */
2319
    }
2320
    put_bits(&s->pb, 1, 0);                /* scalability */
2321 5596c60c Michael Niedermayer
    
2322 92073d01 Michael Niedermayer
    ff_mpeg4_stuffing(&s->pb);
2323 49c9325f Michael Niedermayer
2324 5596c60c Michael Niedermayer
    /* user data */
2325 b0368839 Michael Niedermayer
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
2326 5596c60c Michael Niedermayer
        put_bits(&s->pb, 16, 0);
2327
        put_bits(&s->pb, 16, 0x1B2);        /* user_data */
2328 99683a30 Michael Niedermayer
        put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2329 5596c60c Michael Niedermayer
    }
2330 10cd5815 Michael Niedermayer
}
2331
2332
/* write mpeg4 VOP header */
2333
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2334
{
2335 9dbcbd92 Michael Niedermayer
    int time_incr;
2336
    int time_div, time_mod;
2337
    
2338 92073d01 Michael Niedermayer
    if(s->pict_type==I_TYPE){
2339 70ac76c0 Michael Niedermayer
        if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2340 3f6f76af Michael Niedermayer
            if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2341
                mpeg4_encode_visual_object_header(s);
2342
            if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2343
                mpeg4_encode_vol_header(s, 0, 0);
2344 41773b73 Michael Niedermayer
        }
2345
        mpeg4_encode_gop_header(s);
2346 92073d01 Michael Niedermayer
    }
2347 9dbcbd92 Michael Niedermayer
    
2348 4d2858de Michael Niedermayer
    s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2349
2350 9dbcbd92 Michael Niedermayer
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2351
    
2352 17592475 Michael Niedermayer
    put_bits(&s->pb, 16, 0);                /* vop header */
2353 41773b73 Michael Niedermayer
    put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2354 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 2, s->pict_type - 1);        /* pict type: I = 0 , P = 1 */
2355 9dbcbd92 Michael Niedermayer
2356 91029be7 Michael Niedermayer
    time_div= s->time/s->time_increment_resolution;
2357
    time_mod= s->time%s->time_increment_resolution;
2358 9dbcbd92 Michael Niedermayer
    time_incr= time_div - s->last_time_base;
2359
    while(time_incr--)
2360
        put_bits(&s->pb, 1, 1);
2361
        
2362 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 0);
2363
2364
    put_bits(&s->pb, 1, 1);        /* marker */
2365 9dbcbd92 Michael Niedermayer
    put_bits(&s->pb, s->time_increment_bits, time_mod);        /* time increment */
2366 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 1);        /* marker */
2367
    put_bits(&s->pb, 1, 1);        /* vop coded */
2368 10cd5815 Michael Niedermayer
    if (    s->pict_type == P_TYPE 
2369
        || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2370 de6d9b64 Fabrice Bellard
        put_bits(&s->pb, 1, s->no_rounding);        /* rounding type */
2371
    }
2372
    put_bits(&s->pb, 3, 0);        /* intra dc VLC threshold */
2373 fcb48651 Michael Niedermayer
    if(!s->progressive_sequence){
2374 2be9f03a Michael Niedermayer
         put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2375 fcb48651 Michael Niedermayer
         put_bits(&s->pb, 1, s->alternate_scan);
2376
    }
2377 10cd5815 Michael Niedermayer
    //FIXME sprite stuff
2378 de6d9b64 Fabrice Bellard
2379
    put_bits(&s->pb, 5, s->qscale);
2380
2381
    if (s->pict_type != I_TYPE)
2382
        put_bits(&s->pb, 3, s->f_code);        /* fcode_for */
2383 10cd5815 Michael Niedermayer
    if (s->pict_type == B_TYPE)
2384
        put_bits(&s->pb, 3, s->b_code);        /* fcode_back */
2385 de6d9b64 Fabrice Bellard
    //    printf("****frame %d\n", picture_number);
2386
}
2387
2388 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
2389
2390 4d2858de Michael Niedermayer
/**
2391 554daa24 Michael Niedermayer
 * set qscale and update qscale dependant variables.
2392 4d2858de Michael Niedermayer
 */
2393 554daa24 Michael Niedermayer
void ff_set_qscale(MpegEncContext * s, int qscale)
2394 de6d9b64 Fabrice Bellard
{
2395 554daa24 Michael Niedermayer
    if (qscale < 1)
2396
        qscale = 1;
2397
    else if (qscale > 31)
2398
        qscale = 31;
2399 332f9ac4 Michael Niedermayer
        
2400 554daa24 Michael Niedermayer
    s->qscale = qscale;
2401
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2402 5482970b Michael Niedermayer
2403 554daa24 Michael Niedermayer
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2404 332f9ac4 Michael Niedermayer
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2405 de6d9b64 Fabrice Bellard
}
2406
2407 2ba8f6b8 Michael Niedermayer
/**
2408
 * predicts the dc.
2409
 * @param n block index (0-3 are luma, 4-5 are chroma)
2410
 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2411
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2412
 * @return the quantized predicted dc
2413
 */
2414 0c1a9eda Zdenek Kabelac
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2415 de6d9b64 Fabrice Bellard
{
2416 4278e7a6 Michael Niedermayer
    int a, b, c, wrap, pred, scale;
2417 0c1a9eda Zdenek Kabelac
    uint16_t *dc_val;
2418 de6d9b64 Fabrice Bellard
2419
    /* find prediction */
2420
    if (n < 4) {
2421
        scale = s->y_dc_scale;
2422
    } else {
2423
        scale = s->c_dc_scale;
2424
    }
2425 6d71b382 Michael Niedermayer
    if(IS_3IV1)
2426
        scale= 8;
2427
2428 4278e7a6 Michael Niedermayer
    wrap= s->block_wrap[n];
2429
    dc_val = s->dc_val[0] + s->block_index[n];
2430 de6d9b64 Fabrice Bellard
2431
    /* B C
2432
     * A X 
2433
     */
2434 4278e7a6 Michael Niedermayer
    a = dc_val[ - 1];
2435
    b = dc_val[ - 1 - wrap];
2436
    c = dc_val[ - wrap];
2437 de6d9b64 Fabrice Bellard
2438 4d2858de Michael Niedermayer
    /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2439
    if(s->first_slice_line && n!=3){
2440
        if(n!=2) b=c= 1024;
2441
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2442
    }
2443
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2444
        if(n==0 || n==4 || n==5)
2445
            b=1024;
2446
    }
2447
2448 de6d9b64 Fabrice Bellard
    if (abs(a - b) < abs(b - c)) {
2449
        pred = c;
2450
        *dir_ptr = 1; /* top */
2451
    } else {
2452
        pred = a;
2453
        *dir_ptr = 0; /* left */
2454
    }
2455
    /* we assume pred is positive */
2456 d4961b35 BERO
    pred = FASTDIV((pred + (scale >> 1)), scale);
2457 de6d9b64 Fabrice Bellard
2458
    /* prepare address for prediction update */
2459 4278e7a6 Michael Niedermayer
    *dc_val_ptr = &dc_val[0];
2460 de6d9b64 Fabrice Bellard
2461
    return pred;
2462
}
2463
2464 2ba8f6b8 Michael Niedermayer
/**
2465
 * predicts the ac.
2466
 * @param n block index (0-3 are luma, 4-5 are chroma)
2467
 * @param dir the ac prediction direction
2468
 */
2469 0e15384d Michael Niedermayer
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2470 de6d9b64 Fabrice Bellard
                   int dir)
2471
{
2472 4278e7a6 Michael Niedermayer
    int i;
2473 0c1a9eda Zdenek Kabelac
    int16_t *ac_val, *ac_val1;
2474 1e491e29 Michael Niedermayer
    int8_t * const qscale_table= s->current_picture.qscale_table;
2475 de6d9b64 Fabrice Bellard
2476
    /* find prediction */
2477 4278e7a6 Michael Niedermayer
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2478 de6d9b64 Fabrice Bellard
    ac_val1 = ac_val;
2479
    if (s->ac_pred) {
2480
        if (dir == 0) {
2481 7bc9090a Michael Niedermayer
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2482 de6d9b64 Fabrice Bellard
            /* left prediction */
2483
            ac_val -= 16;
2484 3e6a20a0 Michael Niedermayer
            
2485 1e491e29 Michael Niedermayer
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2486 3e6a20a0 Michael Niedermayer
                /* same qscale */
2487
                for(i=1;i<8;i++) {
2488 b0368839 Michael Niedermayer
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2489 3e6a20a0 Michael Niedermayer
                }
2490
            }else{
2491
                /* different qscale, we must rescale */
2492
                for(i=1;i<8;i++) {
2493 b0368839 Michael Niedermayer
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2494 3e6a20a0 Michael Niedermayer
                }
2495 de6d9b64 Fabrice Bellard
            }
2496
        } else {
2497 7bc9090a Michael Niedermayer
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2498 de6d9b64 Fabrice Bellard
            /* top prediction */
2499 4278e7a6 Michael Niedermayer
            ac_val -= 16 * s->block_wrap[n];
2500 3e6a20a0 Michael Niedermayer
2501 1e491e29 Michael Niedermayer
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2502 3e6a20a0 Michael Niedermayer
                /* same qscale */
2503
                for(i=1;i<8;i++) {
2504 b0368839 Michael Niedermayer
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2505 3e6a20a0 Michael Niedermayer
                }
2506
            }else{
2507
                /* different qscale, we must rescale */
2508
                for(i=1;i<8;i++) {
2509 b0368839 Michael Niedermayer
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2510 3e6a20a0 Michael Niedermayer
                }
2511 de6d9b64 Fabrice Bellard
            }
2512
        }
2513
    }
2514
    /* left copy */
2515
    for(i=1;i<8;i++)
2516 b0368839 Michael Niedermayer
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2517 d930ef19 Michael Niedermayer
2518 de6d9b64 Fabrice Bellard
    /* top copy */
2519
    for(i=1;i<8;i++)
2520 b0368839 Michael Niedermayer
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2521 d930ef19 Michael Niedermayer
2522 de6d9b64 Fabrice Bellard
}
2523
2524 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
2525
2526 2ba8f6b8 Michael Niedermayer
/**
2527
 * encodes the dc value.
2528
 * @param n block index (0-3 are luma, 4-5 are chroma)
2529
 */
2530 92073d01 Michael Niedermayer
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2531 d6231b9e Michael Niedermayer
{
2532 2a164b25 Michael Niedermayer
#if 1
2533 92073d01 Michael Niedermayer
//    if(level<-255 || level>255) printf("dc overflow\n");
2534 2a164b25 Michael Niedermayer
    level+=256;
2535
    if (n < 4) {
2536
        /* luminance */
2537 67725183 Michael Niedermayer
        put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2538 2a164b25 Michael Niedermayer
    } else {
2539
        /* chrominance */
2540 67725183 Michael Niedermayer
        put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2541 2a164b25 Michael Niedermayer
    }
2542
#else
2543 d6231b9e Michael Niedermayer
    int size, v;
2544 de6d9b64 Fabrice Bellard
    /* find number of bits */
2545
    size = 0;
2546
    v = abs(level);
2547
    while (v) {
2548
        v >>= 1;
2549
        size++;
2550
    }
2551
2552
    if (n < 4) {
2553
        /* luminance */
2554
        put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2555
    } else {
2556
        /* chrominance */
2557
        put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2558
    }
2559
2560
    /* encode remaining bits */
2561
    if (size > 0) {
2562
        if (level < 0)
2563
            level = (-level) ^ ((1 << size) - 1);
2564
        put_bits(&s->pb, size, level);
2565
        if (size > 8)
2566
            put_bits(&s->pb, 1, 1);
2567
    }
2568 2a164b25 Michael Niedermayer
#endif
2569 de6d9b64 Fabrice Bellard
}
2570 7604246d Wolfgang Hesseler
2571 2ba8f6b8 Michael Niedermayer
/**
2572
 * encodes a 8x8 block
2573
 * @param n block index (0-3 are luma, 4-5 are chroma)
2574
 */
2575 3db48188 Michael Niedermayer
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2576 0c1a9eda Zdenek Kabelac
                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2577 de6d9b64 Fabrice Bellard
{
2578 d2975f8d Michael Niedermayer
    int i, last_non_zero;
2579
#if 0 //variables for the outcommented version
2580
    int code, sign, last;
2581
#endif
2582 de6d9b64 Fabrice Bellard
    const RLTable *rl;
2583 0c1a9eda Zdenek Kabelac
    uint32_t *bits_tab;
2584
    uint8_t *len_tab;
2585 3db48188 Michael Niedermayer
    const int last_index = s->block_last_index[n];
2586 de6d9b64 Fabrice Bellard
2587 3db48188 Michael Niedermayer
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2588 de6d9b64 Fabrice Bellard
        /* mpeg4 based DC predictor */
2589 92073d01 Michael Niedermayer
        mpeg4_encode_dc(dc_pb, intra_dc, n);
2590 3db48188 Michael Niedermayer
        if(last_index<1) return;
2591 de6d9b64 Fabrice Bellard
        i = 1;
2592
        rl = &rl_intra;
2593 3db48188 Michael Niedermayer
        bits_tab= uni_mpeg4_intra_rl_bits;
2594
        len_tab = uni_mpeg4_intra_rl_len;
2595 de6d9b64 Fabrice Bellard
    } else {
2596 3db48188 Michael Niedermayer
        if(last_index<0) return;
2597 de6d9b64 Fabrice Bellard
        i = 0;
2598
        rl = &rl_inter;
2599 3db48188 Michael Niedermayer
        bits_tab= uni_mpeg4_inter_rl_bits;
2600
        len_tab = uni_mpeg4_inter_rl_len;
2601 de6d9b64 Fabrice Bellard
    }
2602
2603
    /* AC coefs */
2604
    last_non_zero = i - 1;
2605 3db48188 Michael Niedermayer
#if 1
2606
    for (; i < last_index; i++) {
2607
        int level = block[ scan_table[i] ];
2608 de6d9b64 Fabrice Bellard
        if (level) {
2609 3db48188 Michael Niedermayer
            int run = i - last_non_zero - 1;
2610
            level+=64;
2611
            if((level&(~127)) == 0){
2612
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2613
                put_bits(ac_pb, len_tab[index], bits_tab[index]);
2614
            }else{ //ESC3
2615
                put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2616
            }
2617
            last_non_zero = i;
2618
        }
2619
    }
2620
    /*if(i<=last_index)*/{
2621
        int level = block[ scan_table[i] ];
2622
        int run = i - last_non_zero - 1;
2623
        level+=64;
2624
        if((level&(~127)) == 0){
2625
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2626
            put_bits(ac_pb, len_tab[index], bits_tab[index]);
2627
        }else{ //ESC3
2628
            put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2629
        }
2630
    }
2631
#else
2632
    for (; i <= last_index; i++) {
2633
        const int slevel = block[ scan_table[i] ];
2634
        if (slevel) {
2635
            int level;
2636
            int run = i - last_non_zero - 1;
2637 de6d9b64 Fabrice Bellard
            last = (i == last_index);
2638
            sign = 0;
2639 3db48188 Michael Niedermayer
            level = slevel;
2640 de6d9b64 Fabrice Bellard
            if (level < 0) {
2641
                sign = 1;
2642
                level = -level;
2643
            }
2644
            code = get_rl_index(rl, last, run, level);
2645 92073d01 Michael Niedermayer
            put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2646 de6d9b64 Fabrice Bellard
            if (code == rl->n) {
2647
                int level1, run1;
2648
                level1 = level - rl->max_level[last][run];
2649
                if (level1 < 1) 
2650
                    goto esc2;
2651
                code = get_rl_index(rl, last, run, level1);
2652
                if (code == rl->n) {
2653
                esc2:
2654 92073d01 Michael Niedermayer
                    put_bits(ac_pb, 1, 1);
2655 de6d9b64 Fabrice Bellard
                    if (level > MAX_LEVEL)
2656
                        goto esc3;
2657
                    run1 = run - rl->max_run[last][level] - 1;
2658
                    if (run1 < 0)
2659
                        goto esc3;
2660
                    code = get_rl_index(rl, last, run1, level);
2661
                    if (code == rl->n) {
2662
                    esc3:
2663
                        /* third escape */
2664 92073d01 Michael Niedermayer
                        put_bits(ac_pb, 1, 1);
2665
                        put_bits(ac_pb, 1, last);
2666
                        put_bits(ac_pb, 6, run);
2667
                        put_bits(ac_pb, 1, 1);
2668
                        put_bits(ac_pb, 12, slevel & 0xfff);
2669
                        put_bits(ac_pb, 1, 1);
2670 de6d9b64 Fabrice Bellard
                    } else {
2671
                        /* second escape */
2672 92073d01 Michael Niedermayer
                        put_bits(ac_pb, 1, 0);
2673
                        put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2674
                        put_bits(ac_pb, 1, sign);
2675 de6d9b64 Fabrice Bellard
                    }
2676
                } else {
2677
                    /* first escape */
2678 92073d01 Michael Niedermayer
                    put_bits(ac_pb, 1, 0);
2679
                    put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2680
                    put_bits(ac_pb, 1, sign);
2681 de6d9b64 Fabrice Bellard
                }
2682
            } else {
2683 92073d01 Michael Niedermayer
                put_bits(ac_pb, 1, sign);
2684 de6d9b64 Fabrice Bellard
            }
2685
            last_non_zero = i;
2686
        }
2687
    }
2688 3db48188 Michael Niedermayer
#endif
2689 de6d9b64 Fabrice Bellard
}
2690 1457ab52 Michael Niedermayer
2691
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2692 0c1a9eda Zdenek Kabelac
                               uint8_t *scan_table)
2693 1457ab52 Michael Niedermayer
{
2694
    int i, last_non_zero;
2695
    const RLTable *rl;
2696 0c1a9eda Zdenek Kabelac
    uint8_t *len_tab;
2697 1457ab52 Michael Niedermayer
    const int last_index = s->block_last_index[n];
2698
    int len=0;
2699
2700
    if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2701
        /* mpeg4 based DC predictor */
2702
        //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2703
        if(last_index<1) return len;
2704
        i = 1;
2705
        rl = &rl_intra;
2706
        len_tab = uni_mpeg4_intra_rl_len;
2707
    } else {
2708
        if(last_index<0) return 0;
2709
        i = 0;
2710
        rl = &rl_inter;
2711
        len_tab = uni_mpeg4_inter_rl_len;
2712
    }
2713
2714
    /* AC coefs */
2715
    last_non_zero = i - 1;
2716
    for (; i < last_index; i++) {
2717
        int level = block[ scan_table[i] ];
2718
        if (level) {
2719
            int run = i - last_non_zero - 1;
2720
            level+=64;
2721
            if((level&(~127)) == 0){
2722
                const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2723
                len += len_tab[index];
2724
            }else{ //ESC3
2725
                len += 7+2+1+6+1+12+1;
2726
            }
2727
            last_non_zero = i;
2728
        }
2729
    }
2730
    /*if(i<=last_index)*/{
2731
        int level = block[ scan_table[i] ];
2732
        int run = i - last_non_zero - 1;
2733
        level+=64;
2734
        if((level&(~127)) == 0){
2735
            const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2736
            len += len_tab[index];
2737
        }else{ //ESC3
2738
            len += 7+2+1+6+1+12+1;
2739
        }
2740
    }
2741
    
2742
    return len;
2743
}
2744
2745 bbed9259 Michael Niedermayer
#endif
2746 de6d9b64 Fabrice Bellard
2747
2748
/***********************************************/
2749
/* decoding */
2750
2751
static VLC intra_MCBPC_vlc;
2752
static VLC inter_MCBPC_vlc;
2753
static VLC cbpy_vlc;
2754
static VLC mv_vlc;
2755
static VLC dc_lum, dc_chrom;
2756 73c8e514 Michael Niedermayer
static VLC sprite_trajectory;
2757 6f91bcd1 Michael Niedermayer
static VLC mb_type_b_vlc;
2758 b40cd4e0 Michael Niedermayer
static VLC h263_mbtype_b_vlc;
2759
static VLC cbpc_b_vlc;
2760 de6d9b64 Fabrice Bellard
2761
void init_vlc_rl(RLTable *rl)
2762
{
2763 45a82edb Michael Niedermayer
    int i, q;
2764
    
2765 de6d9b64 Fabrice Bellard
    init_vlc(&rl->vlc, 9, rl->n + 1, 
2766
             &rl->table_vlc[0][1], 4, 2,
2767
             &rl->table_vlc[0][0], 4, 2);
2768 45a82edb Michael Niedermayer
2769
    
2770
    for(q=0; q<32; q++){
2771
        int qmul= q*2;
2772
        int qadd= (q-1)|1;
2773
        
2774
        if(q==0){
2775
            qmul=1;
2776
            qadd=0;
2777
        }
2778
        
2779
        rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2780
        for(i=0; i<rl->vlc.table_size; i++){
2781
            int code= rl->vlc.table[i][0];
2782
            int len = rl->vlc.table[i][1];
2783
            int level, run;
2784