Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263.c @ bc0219fd

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

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