Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ da9c9637

History | View | Annotate | Download (208 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 6dbd39fe Juanjo
static void h263p_encode_umotion(MpegEncContext * s, int val);
60 3db48188 Michael Niedermayer
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61 d4f5d74a Garrick Meeker
                               int n, int dc, uint8_t *scan_table, 
62 92073d01 Michael Niedermayer
                               PutBitContext *dc_pb, PutBitContext *ac_pb);
63 bbed9259 Michael Niedermayer
#endif
64
65 6f91bcd1 Michael Niedermayer
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
66 6dbd39fe Juanjo
static int h263p_decode_umotion(MpegEncContext * s, int pred);
67 de6d9b64 Fabrice Bellard
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
68
                             int n, int coded);
69 92073d01 Michael Niedermayer
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
70
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
71 a4e8b587 Michael Niedermayer
                              int n, int coded, int intra, int rvlc);
72 0c1a9eda Zdenek Kabelac
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
73 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
74 22ddd60b Michael Niedermayer
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
75
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
76 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
77 3f9d89c6 Michael Niedermayer
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
78 a7137a04 Michael Niedermayer
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
79 4d2858de Michael Niedermayer
80 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
81 0c1a9eda Zdenek Kabelac
static uint8_t uni_DCtab_lum_len[512];
82
static uint8_t uni_DCtab_chrom_len[512];
83
static uint16_t uni_DCtab_lum_bits[512];
84
static uint16_t uni_DCtab_chrom_bits[512];
85 bbed9259 Michael Niedermayer
86 30952237 Michael Niedermayer
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
87 0c1a9eda Zdenek Kabelac
static uint8_t fcode_tab[MAX_MV*2+1];
88
static uint8_t umv_fcode_tab[MAX_MV*2+1];
89 45870f57 Michael Niedermayer
90 477ab036 Michael Niedermayer
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
91
static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
92
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
93
static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
94 15c5fa7b Michael Niedermayer
static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
95
static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
96 477ab036 Michael Niedermayer
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
97 3db48188 Michael Niedermayer
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
98 477ab036 Michael Niedermayer
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
99 3db48188 Michael Niedermayer
100
/* mpeg4
101
inter
102
max level: 24/6
103
max run: 53/63
104

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