Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 5917d17c

History | View | Annotate | Download (113 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 de6d9b64 Fabrice Bellard
 *
5 ff4ec49e Fabrice Bellard
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9 de6d9b64 Fabrice Bellard
 *
10 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 ff4ec49e Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 cf8039b2 Michael Niedermayer
 *
19 9dbf1ddd Michael Niedermayer
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
20 de6d9b64 Fabrice Bellard
 */
21 202ef8b8 Michael Niedermayer
 
22
#include <ctype.h>
23 de6d9b64 Fabrice Bellard
#include "avcodec.h"
24
#include "dsputil.h"
25
#include "mpegvideo.h"
26 2ad1516a Michael Niedermayer
#include "simple_idct.h"
27 de6d9b64 Fabrice Bellard
28 54329dd5 Nick Kurshev
#ifdef USE_FASTMEMCPY
29
#include "fastmemcpy.h"
30
#endif
31
32 2ad1516a Michael Niedermayer
//#undef NDEBUG
33
//#include <assert.h>
34
35 21af69f7 Fabrice Bellard
static void encode_picture(MpegEncContext *s, int picture_number);
36
static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
37
                                   DCTELEM *block, int n, int qscale);
38 9dbf1ddd Michael Niedermayer
static void dct_unquantize_mpeg2_c(MpegEncContext *s,
39
                                   DCTELEM *block, int n, int qscale);
40 21af69f7 Fabrice Bellard
static void dct_unquantize_h263_c(MpegEncContext *s, 
41
                                  DCTELEM *block, int n, int qscale);
42 3d9fccbf Michael Niedermayer
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
43 d7e9533a Michael Niedermayer
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
44 3d9fccbf Michael Niedermayer
45
void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
46 54993774 Michael Niedermayer
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
47
                                    int src_x, int src_y, int w, int h);
48 3d9fccbf Michael Niedermayer
49 de6d9b64 Fabrice Bellard
#define EDGE_WIDTH 16
50
51
/* enable all paranoid tests for rounding, overflows, etc... */
52
//#define PARANOID
53
54
//#define DEBUG
55
56 101bea5f Juanjo
57 de6d9b64 Fabrice Bellard
/* for jpeg fast DCT */
58
#define CONST_BITS 14
59
60
static const unsigned short aanscales[64] = {
61
    /* precomputed values scaled up by 14 bits */
62
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
63
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
64
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
65
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
66
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
67
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
68
    8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
69
    4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
70
};
71
72
static UINT8 h263_chroma_roundtab[16] = {
73
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
74
};
75
76 9c15096e Michael Niedermayer
static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
77 45870f57 Michael Niedermayer
static UINT8 default_fcode_tab[MAX_MV*2+1];
78
79 101bea5f Juanjo
/* default motion estimation */
80
int motion_estimation_method = ME_EPZS;
81
82 28db7fce Michael Niedermayer
static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
83 cc7ac888 Michael Niedermayer
                           const UINT16 *quant_matrix, int bias, int qmin, int qmax)
84 de6d9b64 Fabrice Bellard
{
85 d7e9533a Michael Niedermayer
    int qscale;
86
87 cc7ac888 Michael Niedermayer
    for(qscale=qmin; qscale<=qmax; qscale++){
88 d7e9533a Michael Niedermayer
        int i;
89 28db7fce Michael Niedermayer
        if (s->fdct == ff_jpeg_fdct_islow) {
90
            for(i=0;i<64;i++) {
91 2ad1516a Michael Niedermayer
                const int j= s->idct_permutation[i];
92 28db7fce Michael Niedermayer
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
93
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
94
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
95
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
96
                
97 ad324c93 Michael Niedermayer
                qmat[qscale][j] = (int)((UINT64_C(1) << QMAT_SHIFT) / 
98 28db7fce Michael Niedermayer
                                (qscale * quant_matrix[j]));
99
            }
100
        } else if (s->fdct == fdct_ifast) {
101 d7e9533a Michael Niedermayer
            for(i=0;i<64;i++) {
102 2ad1516a Michael Niedermayer
                const int j= s->idct_permutation[i];
103 d7e9533a Michael Niedermayer
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
104
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
105
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
106
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
107
                
108 ad324c93 Michael Niedermayer
                qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / 
109 d7e9533a Michael Niedermayer
                                (aanscales[i] * qscale * quant_matrix[j]));
110
            }
111
        } else {
112
            for(i=0;i<64;i++) {
113 2ad1516a Michael Niedermayer
                const int j= s->idct_permutation[i];
114 d7e9533a Michael Niedermayer
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
115
                   So 16           <= qscale * quant_matrix[i]             <= 7905
116
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
117
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
118
                */
119
                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
120 2ad1516a Michael Niedermayer
                qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
121 d7e9533a Michael Niedermayer
122
                if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
123
                qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
124
            }
125 de6d9b64 Fabrice Bellard
        }
126
    }
127
}
128 7f2fe444 Michael Niedermayer
// move into common.c perhaps 
129
#define CHECKED_ALLOCZ(p, size)\
130
{\
131
    p= av_mallocz(size);\
132
    if(p==NULL){\
133
        perror("malloc");\
134
        goto fail;\
135
    }\
136
}
137 2ad1516a Michael Niedermayer
/*
138
static void build_end(void)
139
{
140
    int lastIndex;
141
    int lastIndexAfterPerm=0;
142
    for(lastIndex=0; lastIndex<64; lastIndex++)
143
    {
144
        if(ff_zigzag_direct[lastIndex] > lastIndexAfterPerm) 
145
            lastIndexAfterPerm= ff_zigzag_direct[lastIndex];
146
        zigzag_end[lastIndex]= lastIndexAfterPerm + 1;
147
    }
148
}
149
*/
150
void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
151
    int i;
152
    int end;
153
154
    for(i=0; i<64; i++){
155
        int j;
156
        j = src_scantable[i];
157
        st->permutated[i] = s->idct_permutation[j];
158
    }
159
    
160
    end=-1;
161
    for(i=0; i<64; i++){
162
        int j;
163
        j = st->permutated[i];
164
        if(j>end) end=j;
165
        st->raster_end[i]= end;
166
    }
167
}
168
169
/* XXX: those functions should be suppressed ASAP when all IDCTs are
170
   converted */
171
static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
172
{
173
    j_rev_dct (block);
174
    put_pixels_clamped(block, dest, line_size);
175
}
176
static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
177
{
178
    j_rev_dct (block);
179
    add_pixels_clamped(block, dest, line_size);
180
}
181 de6d9b64 Fabrice Bellard
182
/* init common structure for both encoder and decoder */
183
int MPV_common_init(MpegEncContext *s)
184
{
185
    int c_size, i;
186
    UINT8 *pict;
187
188 3bf43d42 Michael Niedermayer
    s->dct_unquantize_h263 = dct_unquantize_h263_c;
189 9dbf1ddd Michael Niedermayer
    s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
190
    s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
191 28db7fce Michael Niedermayer
    s->dct_quantize= dct_quantize_c;
192
193
    if(s->avctx->dct_algo==FF_DCT_FASTINT)
194
        s->fdct = fdct_ifast;
195
    else
196 2ad1516a Michael Niedermayer
        s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
197
198
    if(s->avctx->idct_algo==FF_IDCT_INT){
199
        s->idct_put= ff_jref_idct_put;
200
        s->idct_add= ff_jref_idct_add;
201
        for(i=0; i<64; i++)
202
            s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
203
    }else{ //accurate/default
204
        s->idct_put= simple_idct_put;
205
        s->idct_add= simple_idct_add;
206
        for(i=0; i<64; i++)
207
            s->idct_permutation[i]= i;
208
    }
209 21af69f7 Fabrice Bellard
        
210
#ifdef HAVE_MMX
211
    MPV_common_init_mmx(s);
212 a9b3f630 Nick Kurshev
#endif
213 e0580f8c Falk H├╝ffner
#ifdef ARCH_ALPHA
214
    MPV_common_init_axp(s);
215
#endif
216 c7e07931 Martin Olschewski
#ifdef HAVE_MLIB
217
    MPV_common_init_mlib(s);
218
#endif
219 5917d17c Leon van Stuivenberg
#ifdef HAVE_MMI
220
    MPV_common_init_mmi(s);
221
#endif
222 2ad1516a Michael Niedermayer
    
223
224
    /* load & permutate scantables
225
       note: only wmv uses differnt ones 
226
    */
227
    ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
228
    ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
229
    ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
230
    ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
231 d930ef19 Michael Niedermayer
232 de6d9b64 Fabrice Bellard
    s->mb_width = (s->width + 15) / 16;
233
    s->mb_height = (s->height + 15) / 16;
234 b5a093b3 Michael Niedermayer
    
235
    /* set default edge pos, will be overriden in decode_header if needed */
236
    s->h_edge_pos= s->mb_width*16;
237
    s->v_edge_pos= s->mb_height*16;
238 202ef8b8 Michael Niedermayer
    
239
    /* convert fourcc to upper case */
240
    s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)          
241
                     + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
242
                     + (toupper((s->avctx->fourcc>>16)&0xFF)<<16) 
243
                     + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
244 b5a093b3 Michael Niedermayer
245 e03c341e Juanjo
    s->mb_num = s->mb_width * s->mb_height;
246 93a21abd Michael Niedermayer
    if(!(s->flags&CODEC_FLAG_DR1)){
247 0fd90455 Michael Niedermayer
      s->linesize   = s->mb_width * 16 + 2 * EDGE_WIDTH;
248
      s->uvlinesize = s->mb_width * 8  +     EDGE_WIDTH;
249 de6d9b64 Fabrice Bellard
250 93a21abd Michael Niedermayer
      for(i=0;i<3;i++) {
251 de6d9b64 Fabrice Bellard
        int w, h, shift, pict_start;
252
253
        w = s->linesize;
254
        h = s->mb_height * 16 + 2 * EDGE_WIDTH;
255
        shift = (i == 0) ? 0 : 1;
256 0fd90455 Michael Niedermayer
        c_size = (s->linesize>>shift) * (h >> shift);
257
        pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
258 de6d9b64 Fabrice Bellard
259 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(pict, c_size)
260 de6d9b64 Fabrice Bellard
        s->last_picture_base[i] = pict;
261
        s->last_picture[i] = pict + pict_start;
262 b50eef3a Michael Niedermayer
        if(i>0) memset(s->last_picture_base[i], 128, c_size);
263 de6d9b64 Fabrice Bellard
    
264 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(pict, c_size)
265 de6d9b64 Fabrice Bellard
        s->next_picture_base[i] = pict;
266
        s->next_picture[i] = pict + pict_start;
267 b50eef3a Michael Niedermayer
        if(i>0) memset(s->next_picture_base[i], 128, c_size);
268 9dbcbd92 Michael Niedermayer
        
269 7aaf3b98 Michael Niedermayer
        if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
270
        /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but 
271
           do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
272 7f2fe444 Michael Niedermayer
            CHECKED_ALLOCZ(pict, c_size)
273 de6d9b64 Fabrice Bellard
            s->aux_picture_base[i] = pict;
274
            s->aux_picture[i] = pict + pict_start;
275 b50eef3a Michael Niedermayer
            if(i>0) memset(s->aux_picture_base[i], 128, c_size);
276 de6d9b64 Fabrice Bellard
        }
277 93a21abd Michael Niedermayer
      }
278 0fd90455 Michael Niedermayer
      s->ip_buffer_count= 2;
279 de6d9b64 Fabrice Bellard
    }
280 37fbfd0a Juanjo
    
281 9be42dba Michael Niedermayer
    CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
282 93a21abd Michael Niedermayer
    
283 37fbfd0a Juanjo
    if (s->encoding) {
284 9dbcbd92 Michael Niedermayer
        int j;
285
        int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
286 b4dbd87c Juanjo
        
287 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->mb_var   , s->mb_num * sizeof(INT16))
288
        CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
289 c5d309f2 Michael Niedermayer
        CHECKED_ALLOCZ(s->mb_mean  , s->mb_num * sizeof(INT8))
290 9dbcbd92 Michael Niedermayer
291
        /* Allocate MV tables */
292 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
293
        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
294
        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
295
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
296
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
297
        CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
298
        CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
299
        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
300
301
        CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
302
        
303
        CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
304
        CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
305 91029be7 Michael Niedermayer
306 9dbcbd92 Michael Niedermayer
        if(s->max_b_frames){
307
            for(j=0; j<REORDER_BUFFER_SIZE; j++){
308
                int i;
309
                for(i=0;i<3;i++) {
310
                    int w, h, shift;
311
312
                    w = s->linesize;
313
                    h = s->mb_height * 16;
314
                    shift = (i == 0) ? 0 : 1;
315
                    c_size = (w >> shift) * (h >> shift);
316
317 7f2fe444 Michael Niedermayer
                    CHECKED_ALLOCZ(pict, c_size);
318 9dbcbd92 Michael Niedermayer
                    s->picture_buffer[j][i] = pict;
319
                }
320
            }
321
        }
322 7f2fe444 Michael Niedermayer
323
        if(s->codec_id==CODEC_ID_MPEG4){
324
            CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
325
            CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
326
        }
327 3aa102be Michael Niedermayer
        
328 6b460aa3 Michael Niedermayer
        if(s->msmpeg4_version){
329
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
330
        }
331 3aa102be Michael Niedermayer
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
332 37fbfd0a Juanjo
    }
333
    
334 174489bd Michael Niedermayer
    if (s->out_format == FMT_H263 || s->encoding) {
335 de6d9b64 Fabrice Bellard
        int size;
336 7f2fe444 Michael Niedermayer
        /* Allocate MB type table */
337
        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
338
339 de6d9b64 Fabrice Bellard
        /* MV prediction */
340
        size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
341 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
342 bea669e5 Michael Niedermayer
    }
343
344
    if(s->codec_id==CODEC_ID_MPEG4){
345
        /* 4mv and interlaced direct mode decoding tables */
346
        CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
347
        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
348
        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
349 de6d9b64 Fabrice Bellard
    }
350
351 d140623f Juanjo
    if (s->h263_pred || s->h263_plus) {
352 de6d9b64 Fabrice Bellard
        int y_size, c_size, i, size;
353
        
354
        /* dc values */
355
356
        y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
357
        c_size = (s->mb_width + 2) * (s->mb_height + 2);
358
        size = y_size + 2 * c_size;
359 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
360 de6d9b64 Fabrice Bellard
        s->dc_val[1] = s->dc_val[0] + y_size;
361
        s->dc_val[2] = s->dc_val[1] + c_size;
362
        for(i=0;i<size;i++)
363
            s->dc_val[0][i] = 1024;
364
365
        /* ac values */
366 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->ac_val[0], size * sizeof(INT16) * 16);
367 de6d9b64 Fabrice Bellard
        s->ac_val[1] = s->ac_val[0] + y_size;
368
        s->ac_val[2] = s->ac_val[1] + c_size;
369
        
370
        /* cbp values */
371 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->coded_block, y_size);
372 eec1c6b9 Michael Niedermayer
        
373
        /* divx501 bitstream reorder buffer */
374 7f2fe444 Michael Niedermayer
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
375
        
376
        /* cbp, ac_pred, pred_dir */
377
        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
378
        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
379 5b3438c6 Michael Niedermayer
    }
380 3e6a20a0 Michael Niedermayer
    CHECKED_ALLOCZ(s->qscale_table  , s->mb_num * sizeof(UINT8))
381
    
382 7806197d Michael Niedermayer
    /* which mb is a intra block */
383
    CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
384
    memset(s->mbintra_table, 1, s->mb_num);
385
    
386 de6d9b64 Fabrice Bellard
    /* default structure is frame */
387
    s->picture_structure = PICT_FRAME;
388 93a21abd Michael Niedermayer
    
389 3bb4e23a Fabrice Bellard
    /* init macroblock skip table */
390 7f2fe444 Michael Niedermayer
    CHECKED_ALLOCZ(s->mbskip_table, s->mb_num);
391 ba6802de Michael Niedermayer
    
392 91029be7 Michael Niedermayer
    s->block= s->blocks[0];
393 3bb4e23a Fabrice Bellard
394 de6d9b64 Fabrice Bellard
    s->context_initialized = 1;
395
    return 0;
396
 fail:
397 8257bf05 Zdenek Kabelac
    MPV_common_end(s);
398 de6d9b64 Fabrice Bellard
    return -1;
399
}
400
401 7f2fe444 Michael Niedermayer
402
//extern int sads;
403
404 de6d9b64 Fabrice Bellard
/* init common structure for both encoder and decoder */
405
void MPV_common_end(MpegEncContext *s)
406
{
407
    int i;
408
409 6000abfa Fabrice Bellard
    av_freep(&s->mb_type);
410
    av_freep(&s->mb_var);
411 7f2fe444 Michael Niedermayer
    av_freep(&s->mc_mb_var);
412 c5d309f2 Michael Niedermayer
    av_freep(&s->mb_mean);
413 6000abfa Fabrice Bellard
    av_freep(&s->p_mv_table);
414
    av_freep(&s->b_forw_mv_table);
415
    av_freep(&s->b_back_mv_table);
416
    av_freep(&s->b_bidir_forw_mv_table);
417
    av_freep(&s->b_bidir_back_mv_table);
418
    av_freep(&s->b_direct_forw_mv_table);
419
    av_freep(&s->b_direct_back_mv_table);
420
    av_freep(&s->b_direct_mv_table);
421
    av_freep(&s->motion_val);
422
    av_freep(&s->dc_val[0]);
423
    av_freep(&s->ac_val[0]);
424
    av_freep(&s->coded_block);
425
    av_freep(&s->mbintra_table);
426 7f2fe444 Michael Niedermayer
    av_freep(&s->cbp_table);
427
    av_freep(&s->pred_dir_table);
428
    av_freep(&s->qscale_table);
429 6000abfa Fabrice Bellard
    av_freep(&s->me_scratchpad);
430 7f2fe444 Michael Niedermayer
    av_freep(&s->me_map);
431
    av_freep(&s->me_score_map);
432
    
433 6000abfa Fabrice Bellard
    av_freep(&s->mbskip_table);
434
    av_freep(&s->bitstream_buffer);
435 7f2fe444 Michael Niedermayer
    av_freep(&s->tex_pb_buffer);
436
    av_freep(&s->pb2_buffer);
437 93a21abd Michael Niedermayer
    av_freep(&s->edge_emu_buffer);
438 bea669e5 Michael Niedermayer
    av_freep(&s->co_located_type_table);
439
    av_freep(&s->field_mv_table);
440
    av_freep(&s->field_select_table);
441 3aa102be Michael Niedermayer
    av_freep(&s->avctx->stats_out);
442 6b460aa3 Michael Niedermayer
    av_freep(&s->ac_stats);
443 3aa102be Michael Niedermayer
    
444 de6d9b64 Fabrice Bellard
    for(i=0;i<3;i++) {
445 9dbcbd92 Michael Niedermayer
        int j;
446 93a21abd Michael Niedermayer
        if(!(s->flags&CODEC_FLAG_DR1)){
447
            av_freep(&s->last_picture_base[i]);
448
            av_freep(&s->next_picture_base[i]);
449
            av_freep(&s->aux_picture_base[i]);
450
        }
451
        s->last_picture_base[i]=
452
        s->next_picture_base[i]=
453
        s->aux_picture_base [i] = NULL;
454
        s->last_picture[i]=
455
        s->next_picture[i]=
456
        s->aux_picture [i] = NULL;
457
458 9dbcbd92 Michael Niedermayer
        for(j=0; j<REORDER_BUFFER_SIZE; j++){
459 6000abfa Fabrice Bellard
            av_freep(&s->picture_buffer[j][i]);
460 9dbcbd92 Michael Niedermayer
        }
461 de6d9b64 Fabrice Bellard
    }
462
    s->context_initialized = 0;
463
}
464
465
/* init video encoder */
466
int MPV_encode_init(AVCodecContext *avctx)
467
{
468
    MpegEncContext *s = avctx->priv_data;
469 519c2b6d Fabrice Bellard
    int i;
470 de6d9b64 Fabrice Bellard
471 bc657ac3 Zdenek Kabelac
    avctx->pix_fmt = PIX_FMT_YUV420P;
472
473 de6d9b64 Fabrice Bellard
    s->bit_rate = avctx->bit_rate;
474 9cdd6a24 Michael Niedermayer
    s->bit_rate_tolerance = avctx->bit_rate_tolerance;
475 de6d9b64 Fabrice Bellard
    s->frame_rate = avctx->frame_rate;
476
    s->width = avctx->width;
477
    s->height = avctx->height;
478 7f2fe444 Michael Niedermayer
    if(avctx->gop_size > 600){
479 333547be Michael Niedermayer
        fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
480 7f2fe444 Michael Niedermayer
        avctx->gop_size=600;
481
    }
482 de6d9b64 Fabrice Bellard
    s->gop_size = avctx->gop_size;
483 644d98a4 Juanjo
    s->rtp_mode = avctx->rtp_mode;
484
    s->rtp_payload_size = avctx->rtp_payload_size;
485 81401c1f Juanjo
    if (avctx->rtp_callback)
486
        s->rtp_callback = avctx->rtp_callback;
487 9cdd6a24 Michael Niedermayer
    s->qmin= avctx->qmin;
488
    s->qmax= avctx->qmax;
489
    s->max_qdiff= avctx->max_qdiff;
490
    s->qcompress= avctx->qcompress;
491
    s->qblur= avctx->qblur;
492 477c35a9 Arpi
    s->avctx = avctx;
493 11ce8834 Michael Niedermayer
    s->aspect_ratio_info= avctx->aspect_ratio_info;
494 e769f053 Alex Beregszaszi
    if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
495
    {
496
        s->aspected_width = avctx->aspected_width;
497
        s->aspected_height = avctx->aspected_height;
498
    }
499 ba6802de Michael Niedermayer
    s->flags= avctx->flags;
500 9dbcbd92 Michael Niedermayer
    s->max_b_frames= avctx->max_b_frames;
501 8b4c7dbc Michael Niedermayer
    s->b_frame_strategy= avctx->b_frame_strategy;
502 d7e9533a Michael Niedermayer
    s->codec_id= avctx->codec->id;
503 7f2fe444 Michael Niedermayer
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
504
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
505
    s->strict_std_compliance= avctx->strict_std_compliance;
506
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
507 87f8cab4 Michael Niedermayer
    s->mpeg_quant= avctx->mpeg_quant;
508 d7e9533a Michael Niedermayer
509 de6d9b64 Fabrice Bellard
    if (s->gop_size <= 1) {
510
        s->intra_only = 1;
511
        s->gop_size = 12;
512
    } else {
513
        s->intra_only = 0;
514
    }
515 5e746b99 Michael Niedermayer
516 e4986da9 Juanjo
    /* ME algorithm */
517 101bea5f Juanjo
    if (avctx->me_method == 0)
518
        /* For compatibility */
519
        s->me_method = motion_estimation_method;
520
    else
521
        s->me_method = avctx->me_method;
522 5e746b99 Michael Niedermayer
523 e4986da9 Juanjo
    /* Fixed QSCALE */
524 de6d9b64 Fabrice Bellard
    s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
525 37fbfd0a Juanjo
    
526 c5d309f2 Michael Niedermayer
    s->adaptive_quant= (   s->avctx->lumi_masking
527 5e746b99 Michael Niedermayer
                        || s->avctx->dark_masking
528 c5d309f2 Michael Niedermayer
                        || s->avctx->temporal_cplx_masking 
529
                        || s->avctx->spatial_cplx_masking
530
                        || s->avctx->p_masking)
531
                       && !s->fixed_qscale;
532 fcb48651 Michael Niedermayer
    
533
    s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
534 5e746b99 Michael Niedermayer
535 de6d9b64 Fabrice Bellard
    switch(avctx->codec->id) {
536
    case CODEC_ID_MPEG1VIDEO:
537
        s->out_format = FMT_MPEG1;
538 1ff662cc Michael Niedermayer
        avctx->delay=0; //FIXME not sure, should check the spec
539 de6d9b64 Fabrice Bellard
        break;
540
    case CODEC_ID_MJPEG:
541
        s->out_format = FMT_MJPEG;
542
        s->intra_only = 1; /* force intra only for jpeg */
543 37fbfd0a Juanjo
        s->mjpeg_write_tables = 1; /* write all tables */
544 a69b930c Alex Beregszaszi
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
545 37fbfd0a Juanjo
        s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
546
        s->mjpeg_vsample[1] = 1; /* the only currently supported values */
547
        s->mjpeg_vsample[2] = 1; 
548 a69b930c Alex Beregszaszi
        s->mjpeg_hsample[0] = 2;
549 37fbfd0a Juanjo
        s->mjpeg_hsample[1] = 1; 
550
        s->mjpeg_hsample[2] = 1; 
551 de6d9b64 Fabrice Bellard
        if (mjpeg_init(s) < 0)
552
            return -1;
553 1ff662cc Michael Niedermayer
        avctx->delay=0;
554 de6d9b64 Fabrice Bellard
        break;
555
    case CODEC_ID_H263:
556 37fbfd0a Juanjo
        if (h263_get_picture_format(s->width, s->height) == 7) {
557
            printf("Input picture size isn't suitable for h263 codec! try h263+\n");
558 de6d9b64 Fabrice Bellard
            return -1;
559 37fbfd0a Juanjo
        }
560 de6d9b64 Fabrice Bellard
        s->out_format = FMT_H263;
561 1ff662cc Michael Niedermayer
        avctx->delay=0;
562 de6d9b64 Fabrice Bellard
        break;
563
    case CODEC_ID_H263P:
564
        s->out_format = FMT_H263;
565 644d98a4 Juanjo
        s->rtp_mode = 1;
566
        s->rtp_payload_size = 1200; 
567 de6d9b64 Fabrice Bellard
        s->h263_plus = 1;
568 6dbd39fe Juanjo
        s->unrestricted_mv = 1;
569 ef5b1b5a Juanjo
        s->h263_aic = 1;
570 544286b3 Juanjo
        
571
        /* These are just to be sure */
572
        s->umvplus = 0;
573
        s->umvplus_dec = 0;
574 1ff662cc Michael Niedermayer
        avctx->delay=0;
575 de6d9b64 Fabrice Bellard
        break;
576
    case CODEC_ID_RV10:
577
        s->out_format = FMT_H263;
578
        s->h263_rv10 = 1;
579 1ff662cc Michael Niedermayer
        avctx->delay=0;
580 de6d9b64 Fabrice Bellard
        break;
581 58f26ba9 Fabrice Bellard
    case CODEC_ID_MPEG4:
582 de6d9b64 Fabrice Bellard
        s->out_format = FMT_H263;
583
        s->h263_pred = 1;
584
        s->unrestricted_mv = 1;
585 9dbcbd92 Michael Niedermayer
        s->has_b_frames= s->max_b_frames ? 1 : 0;
586 1ff662cc Michael Niedermayer
        s->low_delay=0;
587
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 
588 de6d9b64 Fabrice Bellard
        break;
589 84afee34 Michael Niedermayer
    case CODEC_ID_MSMPEG4V1:
590 de6d9b64 Fabrice Bellard
        s->out_format = FMT_H263;
591
        s->h263_msmpeg4 = 1;
592
        s->h263_pred = 1;
593
        s->unrestricted_mv = 1;
594 84afee34 Michael Niedermayer
        s->msmpeg4_version= 1;
595 1ff662cc Michael Niedermayer
        avctx->delay=0;
596 84afee34 Michael Niedermayer
        break;
597
    case CODEC_ID_MSMPEG4V2:
598
        s->out_format = FMT_H263;
599
        s->h263_msmpeg4 = 1;
600
        s->h263_pred = 1;
601
        s->unrestricted_mv = 1;
602
        s->msmpeg4_version= 2;
603 1ff662cc Michael Niedermayer
        avctx->delay=0;
604 84afee34 Michael Niedermayer
        break;
605
    case CODEC_ID_MSMPEG4V3:
606
        s->out_format = FMT_H263;
607
        s->h263_msmpeg4 = 1;
608
        s->h263_pred = 1;
609
        s->unrestricted_mv = 1;
610
        s->msmpeg4_version= 3;
611 1ff662cc Michael Niedermayer
        avctx->delay=0;
612 de6d9b64 Fabrice Bellard
        break;
613 f5957f3f Michael Niedermayer
    case CODEC_ID_WMV1:
614
        s->out_format = FMT_H263;
615
        s->h263_msmpeg4 = 1;
616
        s->h263_pred = 1;
617
        s->unrestricted_mv = 1;
618
        s->msmpeg4_version= 4;
619
        avctx->delay=0;
620
        break;
621
    case CODEC_ID_WMV2:
622
        s->out_format = FMT_H263;
623
        s->h263_msmpeg4 = 1;
624
        s->h263_pred = 1;
625
        s->unrestricted_mv = 1;
626
        s->msmpeg4_version= 5;
627
        avctx->delay=0;
628
        break;
629 de6d9b64 Fabrice Bellard
    default:
630
        return -1;
631
    }
632 cf8039b2 Michael Niedermayer
    
633 45870f57 Michael Niedermayer
    { /* set up some save defaults, some codecs might override them later */
634
        static int done=0;
635
        if(!done){
636
            int i;
637
            done=1;
638 9c15096e Michael Niedermayer
            memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
639 45870f57 Michael Niedermayer
            memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
640
641
            for(i=-16; i<16; i++){
642
                default_fcode_tab[i + MAX_MV]= 1;
643
            }
644
        }
645
    }
646
    s->mv_penalty= default_mv_penalty;
647
    s->fcode_tab= default_fcode_tab;
648 a406617f Michael Niedermayer
    s->y_dc_scale_table=
649
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
650
 
651 9d2a0355 Michael Niedermayer
    /* dont use mv_penalty table for crap MV as it would be confused */
652 9dbcbd92 Michael Niedermayer
    if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
653 9d2a0355 Michael Niedermayer
654 3bb4e23a Fabrice Bellard
    s->encoding = 1;
655
656 de6d9b64 Fabrice Bellard
    /* init */
657
    if (MPV_common_init(s) < 0)
658
        return -1;
659
    
660 2ad1516a Michael Niedermayer
    if (s->out_format == FMT_H263)
661
        h263_encode_init(s);
662
    else if (s->out_format == FMT_MPEG1)
663
        ff_mpeg1_encode_init(s);
664
    if(s->msmpeg4_version)
665
        ff_msmpeg4_encode_init(s);
666
667 519c2b6d Fabrice Bellard
    /* init default q matrix */
668
    for(i=0;i<64;i++) {
669 2ad1516a Michael Niedermayer
        int j= s->idct_permutation[i];
670 87f8cab4 Michael Niedermayer
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
671 2ad1516a Michael Niedermayer
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
672
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
673 87f8cab4 Michael Niedermayer
        }else if(s->out_format == FMT_H263){
674 2ad1516a Michael Niedermayer
            s->intra_matrix[j] =
675
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
676 87f8cab4 Michael Niedermayer
        }else{ /* mpeg1 */
677 2ad1516a Michael Niedermayer
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
678
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
679 87f8cab4 Michael Niedermayer
        }
680 d7e9533a Michael Niedermayer
    }
681
682
    /* precompute matrix */
683 ef5b1b5a Juanjo
    /* for mjpeg, we do include qscale in the matrix */
684 d7e9533a Michael Niedermayer
    if (s->out_format != FMT_MJPEG) {
685 28db7fce Michael Niedermayer
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
686 cc7ac888 Michael Niedermayer
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
687 28db7fce Michael Niedermayer
        convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
688 cc7ac888 Michael Niedermayer
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
689 519c2b6d Fabrice Bellard
    }
690
691 8b4c7dbc Michael Niedermayer
    if(ff_rate_control_init(s) < 0)
692
        return -1;
693 de6d9b64 Fabrice Bellard
694
    s->picture_number = 0;
695 45870f57 Michael Niedermayer
    s->picture_in_gop_number = 0;
696 de6d9b64 Fabrice Bellard
    s->fake_picture_number = 0;
697
    /* motion detector init */
698
    s->f_code = 1;
699 9dbcbd92 Michael Niedermayer
    s->b_code = 1;
700 de6d9b64 Fabrice Bellard
701
    return 0;
702
}
703
704
int MPV_encode_end(AVCodecContext *avctx)
705
{
706
    MpegEncContext *s = avctx->priv_data;
707
708
#ifdef STATS
709
    print_stats();
710
#endif
711 8b4c7dbc Michael Niedermayer
712
    ff_rate_control_uninit(s);
713
714 de6d9b64 Fabrice Bellard
    MPV_common_end(s);
715
    if (s->out_format == FMT_MJPEG)
716
        mjpeg_close(s);
717 37fbfd0a Juanjo
      
718 de6d9b64 Fabrice Bellard
    return 0;
719
}
720
721
/* draw the edges of width 'w' of an image of size width, height */
722 fd7db0fd Michael Niedermayer
//FIXME check that this is ok for mpeg4 interlaced
723 3d9fccbf Michael Niedermayer
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
724 de6d9b64 Fabrice Bellard
{
725
    UINT8 *ptr, *last_line;
726
    int i;
727
728
    last_line = buf + (height - 1) * wrap;
729
    for(i=0;i<w;i++) {
730
        /* top and bottom */
731
        memcpy(buf - (i + 1) * wrap, buf, width);
732
        memcpy(last_line + (i + 1) * wrap, last_line, width);
733
    }
734
    /* left and right */
735
    ptr = buf;
736
    for(i=0;i<height;i++) {
737
        memset(ptr - w, ptr[0], w);
738
        memset(ptr + width, ptr[width-1], w);
739
        ptr += wrap;
740
    }
741
    /* corners */
742
    for(i=0;i<w;i++) {
743
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
744
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
745
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
746
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
747
    }
748
}
749
750
/* generic function for encode/decode called before a frame is coded/decoded */
751 93a21abd Michael Niedermayer
void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
752 de6d9b64 Fabrice Bellard
{
753
    int i;
754
    UINT8 *tmp;
755
756 425dddb7 Fabrice Bellard
    s->mb_skiped = 0;
757 7f2fe444 Michael Niedermayer
    s->decoding_error=0;
758 fe072fb4 Michael Niedermayer
    avctx->mbskip_table= s->mbskip_table;
759 7f2fe444 Michael Niedermayer
760 93a21abd Michael Niedermayer
    if(avctx->flags&CODEC_FLAG_DR1){
761
        avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
762
763 0fd90455 Michael Niedermayer
        s->linesize  = avctx->dr_stride;
764
        s->uvlinesize= avctx->dr_uvstride;
765
        s->ip_buffer_count= avctx->dr_ip_buffer_count;
766 93a21abd Michael Niedermayer
    }
767 fe072fb4 Michael Niedermayer
    avctx->dr_ip_buffer_count= s->ip_buffer_count;
768 93a21abd Michael Niedermayer
    
769 de6d9b64 Fabrice Bellard
    if (s->pict_type == B_TYPE) {
770
        for(i=0;i<3;i++) {
771 93a21abd Michael Niedermayer
            if(avctx->flags&CODEC_FLAG_DR1)
772
                s->aux_picture[i]= avctx->dr_buffer[i];
773 9022797b Michael Niedermayer
            
774
            //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
775
            if(s->next_picture[i]==NULL)
776
                s->next_picture[i]= s->aux_picture[i];
777
            if(s->last_picture[i]==NULL)
778
                s->last_picture[i]= s->next_picture[i];
779 93a21abd Michael Niedermayer
780 de6d9b64 Fabrice Bellard
            s->current_picture[i] = s->aux_picture[i];
781
        }
782
    } else {
783
        for(i=0;i<3;i++) {
784
            /* swap next and last */
785 93a21abd Michael Niedermayer
            if(avctx->flags&CODEC_FLAG_DR1)
786
                tmp= avctx->dr_buffer[i];
787
            else
788
                tmp = s->last_picture[i];
789
790 de6d9b64 Fabrice Bellard
            s->last_picture[i] = s->next_picture[i];
791
            s->next_picture[i] = tmp;
792
            s->current_picture[i] = tmp;
793 93a21abd Michael Niedermayer
794 b7adc711 Michael Niedermayer
            if(s->last_picture[i]==NULL)
795
                s->last_picture[i]= s->next_picture[i];
796
797 93a21abd Michael Niedermayer
            s->last_dr_opaque= s->next_dr_opaque;
798
            s->next_dr_opaque= avctx->dr_opaque_frame;
799
800 760acb18 Michael Niedermayer
            if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
801 93a21abd Michael Niedermayer
                avctx->dr_opaque_frame= s->last_dr_opaque;
802
            else
803
                avctx->dr_opaque_frame= s->next_dr_opaque;
804 de6d9b64 Fabrice Bellard
        }
805
    }
806 d930ef19 Michael Niedermayer
    /* set dequantizer, we cant do it during init as it might change for mpeg4
807
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
808
    if(s->out_format == FMT_H263){
809
        if(s->mpeg_quant)
810
            s->dct_unquantize = s->dct_unquantize_mpeg2;
811
        else
812
            s->dct_unquantize = s->dct_unquantize_h263;
813
    }else 
814
        s->dct_unquantize = s->dct_unquantize_mpeg1;
815 de6d9b64 Fabrice Bellard
}
816 21af69f7 Fabrice Bellard
817 de6d9b64 Fabrice Bellard
/* generic function for encode/decode called after a frame has been coded/decoded */
818
void MPV_frame_end(MpegEncContext *s)
819
{
820 208d3ddf Michael Niedermayer
    s->avctx->key_frame   = (s->pict_type == I_TYPE);
821
    s->avctx->pict_type   = s->pict_type;
822 7f2fe444 Michael Niedermayer
823 de6d9b64 Fabrice Bellard
    /* draw edge for correct motion prediction if outside */
824 93a21abd Michael Niedermayer
    if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
825 b5a093b3 Michael Niedermayer
        draw_edges(s->current_picture[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
826
        draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
827
        draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
828 de6d9b64 Fabrice Bellard
    }
829 5975626d Michael Niedermayer
    emms_c();
830 8b4c7dbc Michael Niedermayer
    
831 3aa102be Michael Niedermayer
    s->last_pict_type    = s->pict_type;
832 8b4c7dbc Michael Niedermayer
    if(s->pict_type!=B_TYPE){
833
        s->last_non_b_pict_type= s->pict_type;
834 1c2a8c7f Michael Niedermayer
        s->num_available_buffers++;
835
        if(s->num_available_buffers>2) s->num_available_buffers= 2;
836 8b4c7dbc Michael Niedermayer
    }
837 de6d9b64 Fabrice Bellard
}
838
839 9dbcbd92 Michael Niedermayer
/* reorder input for encoding */
840
void reorder_input(MpegEncContext *s, AVPicture *pict)
841
{
842
    int i, j, index;
843
            
844
    if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
845
846
//        delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
847
848
    for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
849
        s->coded_order[j]= s->coded_order[j+1];
850
    }
851
    s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
852 d697b89b Michael Niedermayer
    s->coded_order[j].pict_type=0;
853 9dbcbd92 Michael Niedermayer
854
    switch(s->input_pict_type){
855
    default: 
856
    case I_TYPE:
857
    case S_TYPE:
858
    case P_TYPE:
859
        index= s->max_b_frames - s->b_frames_since_non_b;
860
        s->b_frames_since_non_b=0;
861
        break;            
862
    case B_TYPE:
863
        index= s->max_b_frames + 1;
864
        s->b_frames_since_non_b++;
865
        break;          
866
    }
867
//printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
868
    if(   (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
869
       && pict->linesize[0] == s->linesize
870 0fd90455 Michael Niedermayer
       && pict->linesize[1] == s->uvlinesize
871
       && pict->linesize[2] == s->uvlinesize){
872 9dbcbd92 Michael Niedermayer
//printf("ptr\n");
873
        for(i=0; i<3; i++){
874
            s->coded_order[index].picture[i]= pict->data[i];
875
        }
876
    }else{
877
//printf("copy\n");
878
        for(i=0; i<3; i++){
879
            uint8_t *src = pict->data[i];
880
            uint8_t *dest;
881
            int src_wrap = pict->linesize[i];
882
            int dest_wrap = s->linesize;
883
            int w = s->width;
884
            int h = s->height;
885
886
            if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
887
            else         dest= s->picture_buffer[s->picture_buffer_index][i];
888
889
            if (i >= 1) {
890
                dest_wrap >>= 1;
891
                w >>= 1;
892
                h >>= 1;
893
            }
894
895
            s->coded_order[index].picture[i]= dest;
896
            for(j=0;j<h;j++) {
897
                memcpy(dest, src, w);
898
                dest += dest_wrap;
899
                src += src_wrap;
900
            }
901
        }
902
        if(index!=0){
903
            s->picture_buffer_index++;
904 a10678da Michael Niedermayer
            if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
905 9dbcbd92 Michael Niedermayer
        }
906
    }
907
    s->coded_order[index].pict_type = s->input_pict_type;
908
    s->coded_order[index].qscale    = s->input_qscale;
909
    s->coded_order[index].force_type= s->force_input_type;
910
    s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
911
    s->coded_order[index].picture_number= s->input_picture_number;
912
913
    for(i=0; i<3; i++){
914
        s->new_picture[i]= s->coded_order[0].picture[i];
915
    }
916
}
917
918 de6d9b64 Fabrice Bellard
int MPV_encode_picture(AVCodecContext *avctx,
919
                       unsigned char *buf, int buf_size, void *data)
920
{
921
    MpegEncContext *s = avctx->priv_data;
922
    AVPicture *pict = data;
923
924 9dbcbd92 Michael Niedermayer
    s->input_qscale = avctx->quality;
925 de6d9b64 Fabrice Bellard
926
    init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
927
928 8b4c7dbc Michael Niedermayer
    if(avctx->flags&CODEC_FLAG_TYPE){
929
        s->input_pict_type=
930
        s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
931
    }else if(s->flags&CODEC_FLAG_PASS2){
932
        s->input_pict_type=
933
        s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
934
    }else{
935
        s->force_input_type=0;
936
        if (!s->intra_only) {
937
            /* first picture of GOP is intra */
938
            if (s->input_picture_in_gop_number % s->gop_size==0){
939
                s->input_pict_type = I_TYPE;
940
            }else if(s->max_b_frames==0){
941 9dbcbd92 Michael Niedermayer
                s->input_pict_type = P_TYPE;
942 8b4c7dbc Michael Niedermayer
            }else{
943
                if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
944
                    s->input_pict_type = B_TYPE;
945
                else
946
                    s->input_pict_type = P_TYPE;
947
            }
948
        } else {
949
            s->input_pict_type = I_TYPE;
950 9dbcbd92 Michael Niedermayer
        }
951 de6d9b64 Fabrice Bellard
    }
952
953 8b4c7dbc Michael Niedermayer
    if(s->input_pict_type==I_TYPE)
954
        s->input_picture_in_gop_number=0;
955
    
956 9dbcbd92 Michael Niedermayer
    reorder_input(s, pict);
957
    
958
    /* output? */
959
    if(s->coded_order[0].picture[0]){
960
961
        s->pict_type= s->coded_order[0].pict_type;
962
        if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
963
            s->qscale= s->coded_order[0].qscale;
964
        s->force_type= s->coded_order[0].force_type;
965
        s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
966
        s->picture_number= s->coded_order[0].picture_number;
967
968 93a21abd Michael Niedermayer
        MPV_frame_start(s, avctx);
969 9dbcbd92 Michael Niedermayer
970
        encode_picture(s, s->picture_number);
971 208d3ddf Michael Niedermayer
        
972 9cd3766f Juanjo
        avctx->real_pict_num  = s->picture_number;
973 9dbcbd92 Michael Niedermayer
        avctx->header_bits = s->header_bits;
974
        avctx->mv_bits     = s->mv_bits;
975
        avctx->misc_bits   = s->misc_bits;
976
        avctx->i_tex_bits  = s->i_tex_bits;
977
        avctx->p_tex_bits  = s->p_tex_bits;
978
        avctx->i_count     = s->i_count;
979 66370d3f Michael Niedermayer
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
980 9dbcbd92 Michael Niedermayer
        avctx->skip_count  = s->skip_count;
981
982
        MPV_frame_end(s);
983
984
        if (s->out_format == FMT_MJPEG)
985
            mjpeg_picture_trailer(s);
986
987 c5d309f2 Michael Niedermayer
        if(!s->fixed_qscale)
988
            avctx->quality = s->qscale;
989 8b4c7dbc Michael Niedermayer
        
990
        if(s->flags&CODEC_FLAG_PASS1)
991
            ff_write_pass1_stats(s);
992 7f2fe444 Michael Niedermayer
    
993 de6d9b64 Fabrice Bellard
    }
994
995 9dbcbd92 Michael Niedermayer
    s->input_picture_number++;
996
    s->input_picture_in_gop_number++;
997 de6d9b64 Fabrice Bellard
998
    flush_put_bits(&s->pb);
999 9cdd6a24 Michael Niedermayer
    s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1000 3aa102be Michael Niedermayer
    
1001 9cdd6a24 Michael Niedermayer
    s->total_bits += s->frame_bits;
1002 098eefe1 Michael Niedermayer
    avctx->frame_bits  = s->frame_bits;
1003
//printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", 
1004
//s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
1005 3aa102be Michael Niedermayer
#if 0 //dump some stats to stats.txt for testing/debuging
1006
if(s->max_b_frames==0)
1007
{
1008
    static FILE *f=NULL;
1009
    if(!f) f= fopen("stats.txt", "wb");
1010
    get_psnr(pict->data, s->current_picture,
1011
             pict->linesize, s->linesize, avctx);
1012
    fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
1013
}
1014
#endif
1015 17592475 Michael Niedermayer
1016 43f1708f Juanjo
    if (avctx->get_psnr) {
1017
        /* At this point pict->data should have the original frame   */
1018
        /* an s->current_picture should have the coded/decoded frame */
1019
        get_psnr(pict->data, s->current_picture,
1020
                 pict->linesize, s->linesize, avctx);
1021 9dbcbd92 Michael Niedermayer
//        printf("%f\n", avctx->psnr_y);
1022 43f1708f Juanjo
    }
1023 17592475 Michael Niedermayer
    return pbBufPtr(&s->pb) - s->pb.buf;
1024 de6d9b64 Fabrice Bellard
}
1025
1026 44eb4951 Michael Niedermayer
static inline void gmc1_motion(MpegEncContext *s,
1027
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1028
                               int dest_offset,
1029
                               UINT8 **ref_picture, int src_offset,
1030
                               int h)
1031
{
1032
    UINT8 *ptr;
1033 0fd90455 Michael Niedermayer
    int offset, src_x, src_y, linesize, uvlinesize;
1034 44eb4951 Michael Niedermayer
    int motion_x, motion_y;
1035 54993774 Michael Niedermayer
    int emu=0;
1036 44eb4951 Michael Niedermayer
1037 d6231b9e Michael Niedermayer
    if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
1038 44eb4951 Michael Niedermayer
    motion_x= s->sprite_offset[0][0];
1039
    motion_y= s->sprite_offset[0][1];
1040
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1041
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1042
    motion_x<<=(3-s->sprite_warping_accuracy);
1043
    motion_y<<=(3-s->sprite_warping_accuracy);
1044
    src_x = clip(src_x, -16, s->width);
1045
    if (src_x == s->width)
1046
        motion_x =0;
1047
    src_y = clip(src_y, -16, s->height);
1048
    if (src_y == s->height)
1049
        motion_y =0;
1050
    
1051
    linesize = s->linesize;
1052 0fd90455 Michael Niedermayer
    uvlinesize = s->uvlinesize;
1053 44eb4951 Michael Niedermayer
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1054
1055
    dest_y+=dest_offset;
1056 54993774 Michael Niedermayer
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1057 b5a093b3 Michael Niedermayer
        if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
1058
                              || src_y + (motion_y&15) + h  > s->v_edge_pos){
1059
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1060 54993774 Michael Niedermayer
            ptr= s->edge_emu_buffer;
1061
            emu=1;
1062
        }
1063
    }
1064 44eb4951 Michael Niedermayer
    gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1065
    gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1066
1067
    motion_x= s->sprite_offset[1][0];
1068
    motion_y= s->sprite_offset[1][1];
1069
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1070
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1071
    motion_x<<=(3-s->sprite_warping_accuracy);
1072
    motion_y<<=(3-s->sprite_warping_accuracy);
1073
    src_x = clip(src_x, -8, s->width>>1);
1074
    if (src_x == s->width>>1)
1075
        motion_x =0;
1076
    src_y = clip(src_y, -8, s->height>>1);
1077
    if (src_y == s->height>>1)
1078
        motion_y =0;
1079
1080 0fd90455 Michael Niedermayer
    offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1081 44eb4951 Michael Niedermayer
    ptr = ref_picture[1] + offset;
1082 54993774 Michael Niedermayer
    if(emu){
1083 b5a093b3 Michael Niedermayer
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1084 54993774 Michael Niedermayer
        ptr= s->edge_emu_buffer;
1085
    }
1086 0fd90455 Michael Niedermayer
    gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1087 54993774 Michael Niedermayer
    
1088 44eb4951 Michael Niedermayer
    ptr = ref_picture[2] + offset;
1089 54993774 Michael Niedermayer
    if(emu){
1090 b5a093b3 Michael Niedermayer
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1091 54993774 Michael Niedermayer
        ptr= s->edge_emu_buffer;
1092
    }
1093 0fd90455 Michael Niedermayer
    gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1094 44eb4951 Michael Niedermayer
    
1095
    return;
1096
}
1097
1098 54993774 Michael Niedermayer
static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1099 93a21abd Michael Niedermayer
                                    int src_x, int src_y, int w, int h){
1100
    int x, y;
1101
    int start_y, start_x, end_y, end_x;
1102 54993774 Michael Niedermayer
    UINT8 *buf= s->edge_emu_buffer;
1103 b5a093b3 Michael Niedermayer
    
1104 93a21abd Michael Niedermayer
    if(src_y>= h){
1105
        src+= (h-1-src_y)*linesize;
1106
        src_y=h-1;
1107 225f9c44 Michael Niedermayer
    }else if(src_y<=-block_h){
1108
        src+= (1-block_h-src_y)*linesize;
1109
        src_y=1-block_h;
1110 93a21abd Michael Niedermayer
    }
1111
    if(src_x>= w){
1112
        src+= (w-1-src_x);
1113
        src_x=w-1;
1114 225f9c44 Michael Niedermayer
    }else if(src_x<=-block_w){
1115
        src+= (1-block_w-src_x);
1116
        src_x=1-block_w;
1117 93a21abd Michael Niedermayer
    }
1118
1119
    start_y= MAX(0, -src_y);
1120
    start_x= MAX(0, -src_x);
1121
    end_y= MIN(block_h, h-src_y);
1122
    end_x= MIN(block_w, w-src_x);
1123 54993774 Michael Niedermayer
1124 93a21abd Michael Niedermayer
    // copy existing part
1125
    for(y=start_y; y<end_y; y++){
1126
        for(x=start_x; x<end_x; x++){
1127
            buf[x + y*linesize]= src[x + y*linesize];
1128
        }
1129
    }
1130
1131
    //top
1132
    for(y=0; y<start_y; y++){
1133
        for(x=start_x; x<end_x; x++){
1134
            buf[x + y*linesize]= buf[x + start_y*linesize];
1135
        }
1136
    }
1137
1138
    //bottom
1139
    for(y=end_y; y<block_h; y++){
1140
        for(x=start_x; x<end_x; x++){
1141
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1142
        }
1143
    }
1144
                                    
1145
    for(y=0; y<block_h; y++){
1146
       //left
1147
        for(x=0; x<start_x; x++){
1148
            buf[x + y*linesize]= buf[start_x + y*linesize];
1149
        }
1150
       
1151
       //right
1152
        for(x=end_x; x<block_w; x++){
1153
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1154
        }
1155
    }
1156
}
1157
1158
1159 de6d9b64 Fabrice Bellard
/* apply one mpeg motion vector to the three components */
1160
static inline void mpeg_motion(MpegEncContext *s,
1161
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1162
                               int dest_offset,
1163
                               UINT8 **ref_picture, int src_offset,
1164 b3184779 Michael Niedermayer
                               int field_based, op_pixels_func (*pix_op)[4],
1165 de6d9b64 Fabrice Bellard
                               int motion_x, int motion_y, int h)
1166
{
1167
    UINT8 *ptr;
1168 b5a093b3 Michael Niedermayer
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1169 93a21abd Michael Niedermayer
    int emu=0;
1170 b3184779 Michael Niedermayer
#if 0    
1171 44eb4951 Michael Niedermayer
if(s->quarter_sample)
1172
{
1173
    motion_x>>=1;
1174
    motion_y>>=1;
1175
}
1176 b3184779 Michael Niedermayer
#endif
1177 de6d9b64 Fabrice Bellard
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1178
    src_x = s->mb_x * 16 + (motion_x >> 1);
1179
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1180
                
1181
    /* WARNING: do no forget half pels */
1182
    height = s->height >> field_based;
1183 b5a093b3 Michael Niedermayer
    v_edge_pos = s->v_edge_pos >> field_based;
1184 de6d9b64 Fabrice Bellard
    src_x = clip(src_x, -16, s->width);
1185
    if (src_x == s->width)
1186
        dxy &= ~1;
1187
    src_y = clip(src_y, -16, height);
1188
    if (src_y == height)
1189
        dxy &= ~2;
1190 4c9ede2e Michael Niedermayer
    linesize   = s->linesize << field_based;
1191
    uvlinesize = s->uvlinesize << field_based;
1192 de6d9b64 Fabrice Bellard
    ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1193
    dest_y += dest_offset;
1194 93a21abd Michael Niedermayer
1195
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1196 b5a093b3 Michael Niedermayer
        if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1197
                              || src_y + (motion_y&1) + h  > v_edge_pos){
1198
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1199 93a21abd Michael Niedermayer
            ptr= s->edge_emu_buffer;
1200
            emu=1;
1201
        }
1202
    }
1203 b3184779 Michael Niedermayer
    pix_op[0][dxy](dest_y, ptr, linesize, h);
1204 de6d9b64 Fabrice Bellard
1205 b50eef3a Michael Niedermayer
    if(s->flags&CODEC_FLAG_GRAY) return;
1206
1207 de6d9b64 Fabrice Bellard
    if (s->out_format == FMT_H263) {
1208
        dxy = 0;
1209
        if ((motion_x & 3) != 0)
1210
            dxy |= 1;
1211
        if ((motion_y & 3) != 0)
1212
            dxy |= 2;
1213
        mx = motion_x >> 2;
1214
        my = motion_y >> 2;
1215
    } else {
1216
        mx = motion_x / 2;
1217
        my = motion_y / 2;
1218
        dxy = ((my & 1) << 1) | (mx & 1);
1219
        mx >>= 1;
1220
        my >>= 1;
1221
    }
1222
    
1223
    src_x = s->mb_x * 8 + mx;
1224
    src_y = s->mb_y * (8 >> field_based) + my;
1225
    src_x = clip(src_x, -8, s->width >> 1);
1226
    if (src_x == (s->width >> 1))
1227
        dxy &= ~1;
1228
    src_y = clip(src_y, -8, height >> 1);
1229
    if (src_y == (height >> 1))
1230
        dxy &= ~2;
1231 4c9ede2e Michael Niedermayer
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1232 de6d9b64 Fabrice Bellard
    ptr = ref_picture[1] + offset;
1233 93a21abd Michael Niedermayer
    if(emu){
1234 b5a093b3 Michael Niedermayer
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1235 93a21abd Michael Niedermayer
        ptr= s->edge_emu_buffer;
1236
    }
1237 b3184779 Michael Niedermayer
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1238 93a21abd Michael Niedermayer
1239 de6d9b64 Fabrice Bellard
    ptr = ref_picture[2] + offset;
1240 93a21abd Michael Niedermayer
    if(emu){
1241 b5a093b3 Michael Niedermayer
        emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1242 93a21abd Michael Niedermayer
        ptr= s->edge_emu_buffer;
1243
    }
1244 b3184779 Michael Niedermayer
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1245 de6d9b64 Fabrice Bellard
}
1246
1247 44eb4951 Michael Niedermayer
static inline void qpel_motion(MpegEncContext *s,
1248
                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1249
                               int dest_offset,
1250
                               UINT8 **ref_picture, int src_offset,
1251 b3184779 Michael Niedermayer
                               int field_based, op_pixels_func (*pix_op)[4],
1252
                               qpel_mc_func (*qpix_op)[16],
1253 44eb4951 Michael Niedermayer
                               int motion_x, int motion_y, int h)
1254
{
1255
    UINT8 *ptr;
1256 590a6358 Michael Niedermayer
    int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1257 225f9c44 Michael Niedermayer
    int emu=0;
1258 44eb4951 Michael Niedermayer
1259
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1260
    src_x = s->mb_x * 16 + (motion_x >> 2);
1261
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1262
1263
    height = s->height >> field_based;
1264 b5a093b3 Michael Niedermayer
    v_edge_pos = s->v_edge_pos >> field_based;
1265 44eb4951 Michael Niedermayer
    src_x = clip(src_x, -16, s->width);
1266
    if (src_x == s->width)
1267
        dxy &= ~3;
1268
    src_y = clip(src_y, -16, height);
1269
    if (src_y == height)
1270
        dxy &= ~12;
1271
    linesize = s->linesize << field_based;
1272 590a6358 Michael Niedermayer
    uvlinesize = s->uvlinesize << field_based;
1273 44eb4951 Michael Niedermayer
    ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1274
    dest_y += dest_offset;
1275
//printf("%d %d %d\n", src_x, src_y, dxy);
1276 225f9c44 Michael Niedermayer
    
1277
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1278 b5a093b3 Michael Niedermayer
        if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1279
                              || src_y + (motion_y&3) + h  > v_edge_pos){
1280
            emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1281 225f9c44 Michael Niedermayer
            ptr= s->edge_emu_buffer;
1282
            emu=1;
1283
        }
1284
    }
1285 590a6358 Michael Niedermayer
    if(!field_based)
1286
        qpix_op[0][dxy](dest_y, ptr, linesize);
1287
    else{
1288
        //damn interlaced mode
1289
        //FIXME boundary mirroring is not exactly correct here
1290
        qpix_op[1][dxy](dest_y  , ptr  , linesize);
1291
        qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1292
    }
1293 b3184779 Michael Niedermayer
1294 b50eef3a Michael Niedermayer
    if(s->flags&CODEC_FLAG_GRAY) return;
1295
1296 590a6358 Michael Niedermayer
    if(field_based){
1297
        mx= motion_x/2;
1298
        my= motion_y>>1;
1299
    }else if(s->divx_version){
1300
        mx= (motion_x>>1)|(motion_x&1);
1301
        my= (motion_y>>1)|(motion_y&1);
1302
    }else{
1303
        mx= motion_x/2;
1304
        my= motion_y/2;
1305
    }
1306
    mx= (mx>>1)|(mx&1);
1307
    my= (my>>1)|(my&1);
1308
    dxy= (mx&1) | ((my&1)<<1);
1309
    mx>>=1;
1310
    my>>=1;
1311 44eb4951 Michael Niedermayer
1312
    src_x = s->mb_x * 8 + mx;
1313
    src_y = s->mb_y * (8 >> field_based) + my;
1314
    src_x = clip(src_x, -8, s->width >> 1);
1315
    if (src_x == (s->width >> 1))
1316
        dxy &= ~1;
1317
    src_y = clip(src_y, -8, height >> 1);
1318
    if (src_y == (height >> 1))
1319
        dxy &= ~2;
1320
1321 590a6358 Michael Niedermayer
    offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1322 44eb4951 Michael Niedermayer
    ptr = ref_picture[1] + offset;
1323 225f9c44 Michael Niedermayer
    if(emu){
1324 590a6358 Michael Niedermayer
        emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1325 225f9c44 Michael Niedermayer
        ptr= s->edge_emu_buffer;
1326
    }
1327 590a6358 Michael Niedermayer
    pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1328 225f9c44 Michael Niedermayer
    
1329 44eb4951 Michael Niedermayer
    ptr = ref_picture[2] + offset;
1330 225f9c44 Michael Niedermayer
    if(emu){
1331 590a6358 Michael Niedermayer
        emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1332 225f9c44 Michael Niedermayer
        ptr= s->edge_emu_buffer;
1333
    }
1334 590a6358 Michael Niedermayer
    pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1335 44eb4951 Michael Niedermayer
}
1336
1337
1338 de6d9b64 Fabrice Bellard
static inline void MPV_motion(MpegEncContext *s, 
1339
                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1340
                              int dir, UINT8 **ref_picture, 
1341 b3184779 Michael Niedermayer
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1342 de6d9b64 Fabrice Bellard
{
1343
    int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1344
    int mb_x, mb_y, i;
1345
    UINT8 *ptr, *dest;
1346 225f9c44 Michael Niedermayer
    int emu=0;
1347 de6d9b64 Fabrice Bellard
1348
    mb_x = s->mb_x;
1349
    mb_y = s->mb_y;
1350
1351
    switch(s->mv_type) {
1352
    case MV_TYPE_16X16:
1353 44eb4951 Michael Niedermayer
        if(s->mcsel){
1354
            gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1355
                        ref_picture, 0,
1356
                        16);
1357 b3184779 Michael Niedermayer
        }else if(s->quarter_sample){
1358 44eb4951 Michael Niedermayer
            qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1359
                        ref_picture, 0,
1360
                        0, pix_op, qpix_op,
1361
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1362
        }else{
1363
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1364
                        ref_picture, 0,
1365
                        0, pix_op,
1366
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
1367
        }           
1368 de6d9b64 Fabrice Bellard
        break;
1369
    case MV_TYPE_8X8:
1370 1e7bfebe Michael Niedermayer
        mx = 0;
1371
        my = 0;
1372
        if(s->quarter_sample){
1373
            for(i=0;i<4;i++) {
1374
                motion_x = s->mv[dir][i][0];
1375
                motion_y = s->mv[dir][i][1];
1376
1377
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1378
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1379
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1380
                    
1381
                /* WARNING: do no forget half pels */
1382
                src_x = clip(src_x, -16, s->width);
1383
                if (src_x == s->width)
1384
                    dxy &= ~3;
1385
                src_y = clip(src_y, -16, s->height);
1386
                if (src_y == s->height)
1387
                    dxy &= ~12;
1388
                    
1389
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1390
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1391
                    if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1392
                                          || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1393
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1394
                        ptr= s->edge_emu_buffer;
1395
                    }
1396
                }
1397
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1398
                qpix_op[1][dxy](dest, ptr, s->linesize);
1399
1400
                mx += s->mv[dir][i][0]/2;
1401
                my += s->mv[dir][i][1]/2;
1402
            }
1403
        }else{
1404
            for(i=0;i<4;i++) {
1405
                motion_x = s->mv[dir][i][0];
1406
                motion_y = s->mv[dir][i][1];
1407 de6d9b64 Fabrice Bellard
1408 1e7bfebe Michael Niedermayer
                dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1409
                src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1410
                src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1411 de6d9b64 Fabrice Bellard
                    
1412 1e7bfebe Michael Niedermayer
                /* WARNING: do no forget half pels */
1413
                src_x = clip(src_x, -16, s->width);
1414
                if (src_x == s->width)
1415
                    dxy &= ~1;
1416
                src_y = clip(src_y, -16, s->height);
1417
                if (src_y == s->height)
1418
                    dxy &= ~2;
1419 de6d9b64 Fabrice Bellard
                    
1420 1e7bfebe Michael Niedermayer
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1421
                if(s->flags&CODEC_FLAG_EMU_EDGE){
1422
                    if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1423
                                          || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1424
                        emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1425
                        ptr= s->edge_emu_buffer;
1426
                    }
1427 225f9c44 Michael Niedermayer
                }
1428 1e7bfebe Michael Niedermayer
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1429
                pix_op[1][dxy](dest, ptr, s->linesize, 8);
1430
1431
                mx += s->mv[dir][i][0];
1432
                my += s->mv[dir][i][1];
1433 225f9c44 Michael Niedermayer
            }
1434 de6d9b64 Fabrice Bellard
        }
1435 1e7bfebe Michael Niedermayer
1436 b50eef3a Michael Niedermayer
        if(s->flags&CODEC_FLAG_GRAY) break;
1437 de6d9b64 Fabrice Bellard
        /* In case of 8X8, we construct a single chroma motion vector
1438
           with a special rounding */
1439
        for(i=0;i<4;i++) {
1440
        }
1441
        if (mx >= 0)
1442
            mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1443
        else {
1444
            mx = -mx;
1445
            mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1446
        }
1447
        if (my >= 0)
1448
            my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1449
        else {
1450
            my = -my;
1451
            my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1452
        }
1453
        dxy = ((my & 1) << 1) | (mx & 1);
1454
        mx >>= 1;
1455
        my >>= 1;
1456
1457
        src_x = mb_x * 8 + mx;
1458
        src_y = mb_y * 8 + my;
1459
        src_x = clip(src_x, -8, s->width/2);
1460
        if (src_x == s->width/2)
1461
            dxy &= ~1;
1462
        src_y = clip(src_y, -8, s->height/2);
1463
        if (src_y == s->height/2)
1464
            dxy &= ~2;
1465
        
1466 0fd90455 Michael Niedermayer
        offset = (src_y * (s->uvlinesize)) + src_x;
1467 de6d9b64 Fabrice Bellard
        ptr = ref_picture[1] + offset;
1468 225f9c44 Michael Niedermayer
        if(s->flags&CODEC_FLAG_EMU_EDGE){
1469 b5a093b3 Michael Niedermayer
                if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1470
                                      || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1471
                    emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1472 225f9c44 Michael Niedermayer
                    ptr= s->edge_emu_buffer;
1473
                    emu=1;
1474
                }
1475
            }
1476 b3184779 Michael Niedermayer
        pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1477 225f9c44 Michael Niedermayer
1478 de6d9b64 Fabrice Bellard
        ptr = ref_picture[2] + offset;
1479 225f9c44 Michael Niedermayer
        if(emu){
1480 b5a093b3 Michael Niedermayer
            emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1481 225f9c44 Michael Niedermayer
            ptr= s->edge_emu_buffer;
1482
        }
1483 b3184779 Michael Niedermayer
        pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1484 de6d9b64 Fabrice Bellard
        break;
1485
    case MV_TYPE_FIELD:
1486
        if (s->picture_structure == PICT_FRAME) {
1487 590a6358 Michael Niedermayer
            if(s->quarter_sample){
1488
                /* top field */
1489
                qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1490
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1491
                            1, pix_op, qpix_op,
1492
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1493
                /* bottom field */
1494
                qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1495
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1496
                            1, pix_op, qpix_op,
1497
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1498
            }else{
1499
                /* top field */       
1500
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1501
                            ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1502
                            1, pix_op,
1503
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
1504
                /* bottom field */
1505
                mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1506
                            ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1507
                            1, pix_op,
1508
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
1509
            }
1510 de6d9b64 Fabrice Bellard
        } else {
1511
            
1512
1513
        }
1514
        break;
1515
    }
1516
}
1517
1518
1519
/* put block[] to dest[] */
1520
static inline void put_dct(MpegEncContext *s, 
1521
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1522
{
1523 a0201736 Michael Niedermayer
    s->dct_unquantize(s, block, i, s->qscale);
1524 2ad1516a Michael Niedermayer
    s->idct_put (dest, line_size, block);
1525 de6d9b64 Fabrice Bellard
}
1526
1527
/* add block[] to dest[] */
1528
static inline void add_dct(MpegEncContext *s, 
1529
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1530
{
1531 0f440e02 Michael Niedermayer
    if (s->block_last_index[i] >= 0) {
1532 2ad1516a Michael Niedermayer
        s->idct_add (dest, line_size, block);
1533 0f440e02 Michael Niedermayer
    }
1534
}
1535 2417652e Michael Niedermayer
1536 0f440e02 Michael Niedermayer
static inline void add_dequant_dct(MpegEncContext *s, 
1537
                           DCTELEM *block, int i, UINT8 *dest, int line_size)
1538
{
1539 de6d9b64 Fabrice Bellard
    if (s->block_last_index[i] >= 0) {
1540 0f440e02 Michael Niedermayer
        s->dct_unquantize(s, block, i, s->qscale);
1541 9dbcbd92 Michael Niedermayer
1542 2ad1516a Michael Niedermayer
        s->idct_add (dest, line_size, block);
1543 de6d9b64 Fabrice Bellard
    }
1544
}
1545
1546 7f2fe444 Michael Niedermayer
/**
1547
 * cleans dc, ac, coded_block for the current non intra MB
1548
 */
1549
void ff_clean_intra_table_entries(MpegEncContext *s)
1550
{
1551
    int wrap = s->block_wrap[0];
1552
    int xy = s->block_index[0];
1553
    
1554
    s->dc_val[0][xy           ] = 
1555
    s->dc_val[0][xy + 1       ] = 
1556
    s->dc_val[0][xy     + wrap] =
1557
    s->dc_val[0][xy + 1 + wrap] = 1024;
1558
    /* ac pred */
1559
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1560
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1561
    if (s->msmpeg4_version>=3) {
1562
        s->coded_block[xy           ] =
1563
        s->coded_block[xy + 1       ] =
1564
        s->coded_block[xy     + wrap] =
1565
        s->coded_block[xy + 1 + wrap] = 0;
1566
    }
1567
    /* chroma */
1568
    wrap = s->block_wrap[4];
1569
    xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1570
    s->dc_val[1][xy] =
1571
    s->dc_val[2][xy] = 1024;
1572
    /* ac pred */
1573
    memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1574
    memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1575
    
1576
    s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1577
}
1578
1579 de6d9b64 Fabrice Bellard
/* generic function called after a macroblock has been parsed by the
1580
   decoder or after it has been encoded by the encoder.
1581

1582
   Important variables used:
1583
   s->mb_intra : true if intra macroblock
1584
   s->mv_dir   : motion vector direction
1585
   s->mv_type  : motion vector type
1586
   s->mv       : motion vector
1587
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1588
 */
1589
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1590
{
1591 8257bf05 Zdenek Kabelac
    int mb_x, mb_y;
1592 0f440e02 Michael Niedermayer
    const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1593 de6d9b64 Fabrice Bellard
1594
    mb_x = s->mb_x;
1595
    mb_y = s->mb_y;
1596
1597 79e7b305 Arpi
#ifdef FF_POSTPROCESS
1598 ae72cda6 Nick Kurshev
    /* Obsolete. Exists for compatibility with mplayer only. */
1599 79e7b305 Arpi
    quant_store[mb_y][mb_x]=s->qscale;
1600
    //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
1601 ae72cda6 Nick Kurshev
#else
1602 3e6a20a0 Michael Niedermayer
    /* even more obsolete, exists for mplayer xp only */
1603 8696b636 Nick Kurshev
    if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
1604 79e7b305 Arpi
#endif
1605 3e6a20a0 Michael Niedermayer
    s->qscale_table[mb_xy]= s->qscale;
1606 79e7b305 Arpi
1607 de6d9b64 Fabrice Bellard
    /* update DC predictors for P macroblocks */
1608
    if (!s->mb_intra) {
1609 9e15ad28 Juanjo
        if (s->h263_pred || s->h263_aic) {
1610 0f440e02 Michael Niedermayer
            if(s->mbintra_table[mb_xy])
1611 7f2fe444 Michael Niedermayer
                ff_clean_intra_table_entries(s);
1612 de6d9b64 Fabrice Bellard
        } else {
1613 7f2fe444 Michael Niedermayer
            s->last_dc[0] =
1614
            s->last_dc[1] =
1615 de6d9b64 Fabrice Bellard
            s->last_dc[2] = 128 << s->intra_dc_precision;
1616
        }
1617
    }
1618 9e15ad28 Juanjo
    else if (s->h263_pred || s->h263_aic)
1619 0f440e02 Michael Niedermayer
        s->mbintra_table[mb_xy]=1;
1620 bff6ecaa Michael Niedermayer
1621 c5b1c10a Michael Niedermayer
    /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1622 0f440e02 Michael Niedermayer
    if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1623 de6d9b64 Fabrice Bellard
        
1624 0f440e02 Michael Niedermayer
        const int wrap = s->block_wrap[0];
1625
        const int xy = s->block_index[0];
1626 bea669e5 Michael Niedermayer
        const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1627 fd7db0fd Michael Niedermayer
        if(s->mv_type == MV_TYPE_8X8){
1628 bea669e5 Michael Niedermayer
            s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1629 fd7db0fd Michael Niedermayer
        } else {
1630
            int motion_x, motion_y;
1631
            if (s->mb_intra) {
1632
                motion_x = 0;
1633
                motion_y = 0;
1634 bea669e5 Michael Niedermayer
                if(s->co_located_type_table)
1635
                    s->co_located_type_table[mb_index]= 0;
1636 fd7db0fd Michael Niedermayer
            } else if (s->mv_type == MV_TYPE_16X16) {
1637
                motion_x = s->mv[0][0][0];
1638
                motion_y = s->mv[0][0][1];
1639 bea669e5 Michael Niedermayer
                if(s->co_located_type_table)
1640
                    s->co_located_type_table[mb_index]= 0;
1641 fd7db0fd Michael Niedermayer
            } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1642 bea669e5 Michael Niedermayer
                int i;
1643 fd7db0fd Michael Niedermayer
                motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1644
                motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1645
                motion_x = (motion_x>>1) | (motion_x&1);
1646 bea669e5 Michael Niedermayer
                for(i=0; i<2; i++){
1647
                    s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1648
                    s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1649
                    s->field_select_table[mb_index][i]= s->field_select[0][i];
1650
                }
1651
                s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1652 fd7db0fd Michael Niedermayer
            }
1653 de6d9b64 Fabrice Bellard
            /* no update if 8X8 because it has been done during parsing */
1654 8257bf05 Zdenek Kabelac
            s->motion_val[xy][0] = motion_x;
1655
            s->motion_val[xy][1] = motion_y;
1656
            s->motion_val[xy + 1][0] = motion_x;
1657
            s->motion_val[xy + 1][1] = motion_y;
1658
            s->motion_val[xy + wrap][0] = motion_x;
1659
            s->motion_val[xy + wrap][1] = motion_y;
1660
            s->motion_val[xy + 1 + wrap][0] = motion_x;
1661
            s->motion_val[xy + 1 + wrap][1] = motion_y;
1662 de6d9b64 Fabrice Bellard
        }
1663
    }
1664
    
1665 9dbcbd92 Michael Niedermayer
    if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
1666 de6d9b64 Fabrice Bellard
        UINT8 *dest_y, *dest_cb, *dest_cr;
1667 0f440e02 Michael Niedermayer
        int dct_linesize, dct_offset;
1668 b3184779 Michael Niedermayer
        op_pixels_func (*op_pix)[4];
1669
        qpel_mc_func (*op_qpix)[16];
1670 3bb4e23a Fabrice Bellard
1671 9dbcbd92 Michael Niedermayer
        /* avoid copy if macroblock skipped in last frame too 
1672
           dont touch it for B-frames as they need the skip info from the next p-frame */
1673
        if (s->pict_type != B_TYPE) {
1674 0f440e02 Michael Niedermayer
            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1675 3bb4e23a Fabrice Bellard
            if (s->mb_skiped) {
1676
                s->mb_skiped = 0;
1677 0fd90455 Michael Niedermayer
1678
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1679
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1680
1681 9dbcbd92 Michael Niedermayer
                /* if previous was skipped too, then nothing to do ! 
1682
                   skip only during decoding as we might trash the buffers during encoding a bit */
1683 0fd90455 Michael Niedermayer
                if (*mbskip_ptr >= s->ip_buffer_count  && !s->encoding) 
1684 3bb4e23a Fabrice Bellard
                    goto the_end;
1685
            } else {
1686
                *mbskip_ptr = 0; /* not skipped */
1687
            }
1688
        }
1689 de6d9b64 Fabrice Bellard
1690 3994623d Michael Niedermayer
        if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
1691
            dest_y = s->current_picture [0] + mb_x * 16;
1692
            dest_cb = s->current_picture[1] + mb_x * 8;
1693
            dest_cr = s->current_picture[2] + mb_x * 8;
1694
        }else{
1695
            dest_y = s->current_picture [0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1696
            dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1697
            dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1698
        }
1699 de6d9b64 Fabrice Bellard
1700
        if (s->interlaced_dct) {
1701
            dct_linesize = s->linesize * 2;
1702
            dct_offset = s->linesize;
1703
        } else {
1704
            dct_linesize = s->linesize;
1705
            dct_offset = s->linesize * 8;
1706
        }
1707
1708
        if (!s->mb_intra) {
1709
            /* motion handling */
1710 7f2fe444 Michael Niedermayer
            /* decoding or more than one mb_type (MC was allready done otherwise) */
1711 0f440e02 Michael Niedermayer
            if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1712 91029be7 Michael Niedermayer
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
1713 9dbcbd92 Michael Niedermayer
                    op_pix = put_pixels_tab;
1714 b3184779 Michael Niedermayer
                    op_qpix= put_qpel_pixels_tab;
1715 9dbcbd92 Michael Niedermayer
                }else{
1716
                    op_pix = put_no_rnd_pixels_tab;
1717 b3184779 Michael Niedermayer
                    op_qpix= put_no_rnd_qpel_pixels_tab;
1718 9dbcbd92 Michael Niedermayer
                }
1719 de6d9b64 Fabrice Bellard
1720 9dbcbd92 Michael Niedermayer
                if (s->mv_dir & MV_DIR_FORWARD) {
1721
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1722 b3184779 Michael Niedermayer
                    op_pix = avg_pixels_tab;
1723
                    op_qpix= avg_qpel_pixels_tab;
1724 9dbcbd92 Michael Niedermayer
                }
1725
                if (s->mv_dir & MV_DIR_BACKWARD) {
1726
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1727
                }
1728 de6d9b64 Fabrice Bellard
            }
1729
1730 0f440e02 Michael Niedermayer
            /* skip dequant / idct if we are really late ;) */
1731
            if(s->hurry_up>1) goto the_end;
1732
1733 de6d9b64 Fabrice Bellard
            /* add dct residue */
1734 a0201736 Michael Niedermayer
            if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO 
1735
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1736 0f440e02 Michael Niedermayer
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1737
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1738
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1739
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1740
1741 b50eef3a Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
1742 0fd90455 Michael Niedermayer
                    add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1743
                    add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1744 b50eef3a Michael Niedermayer
                }
1745 0f440e02 Michael Niedermayer
            } else {
1746
                add_dct(s, block[0], 0, dest_y, dct_linesize);
1747
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1748
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1749
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1750 de6d9b64 Fabrice Bellard
1751 b50eef3a Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
1752 0fd90455 Michael Niedermayer
                    add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1753
                    add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1754 b50eef3a Michael Niedermayer
                }
1755 0f440e02 Michael Niedermayer
            }
1756 de6d9b64 Fabrice Bellard
        } else {
1757
            /* dct only in intra block */
1758 a0201736 Michael Niedermayer
            if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
1759
                put_dct(s, block[0], 0, dest_y, dct_linesize);
1760
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1761
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1762
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1763
1764
                if(!(s->flags&CODEC_FLAG_GRAY)){
1765
                    put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1766
                    put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1767
                }
1768
            }else{
1769
                s->idct_put(dest_y                 , dct_linesize, block[0]);
1770
                s->idct_put(dest_y              + 8, dct_linesize, block[1]);
1771
                s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
1772
                s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
1773
1774
                if(!(s->flags&CODEC_FLAG_GRAY)){
1775
                    s->idct_put(dest_cb, s->uvlinesize, block[4]);
1776
                    s->idct_put(dest_cr, s->uvlinesize, block[5]);
1777
                }
1778 b50eef3a Michael Niedermayer
            }
1779 de6d9b64 Fabrice Bellard
        }
1780
    }
1781 3bb4e23a Fabrice Bellard
 the_end:
1782 ba6802de Michael Niedermayer
    emms_c(); //FIXME remove
1783 de6d9b64 Fabrice Bellard
}
1784
1785 c9178d86 Michael Niedermayer
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1786 7f2fe444 Michael Niedermayer
{
1787
    static const char tab[64]=
1788
        {3,2,2,1,1,1,1,1,
1789
         1,1,1,1,1,1,1,1,
1790
         1,1,1,1,1,1,1,1,
1791
         0,0,0,0,0,0,0,0,
1792
         0,0,0,0,0,0,0,0,
1793
         0,0,0,0,0,0,0,0,
1794
         0,0,0,0,0,0,0,0,
1795
         0,0,0,0,0,0,0,0};
1796
    int score=0;
1797
    int run=0;
1798
    int i;
1799
    DCTELEM *block= s->block[n];
1800
    const int last_index= s->block_last_index[n];
1801 c9178d86 Michael Niedermayer
    int skip_dc;
1802 7f2fe444 Michael Niedermayer
1803 f5866a03 Michael Niedermayer
    if(threshold<0){
1804
        skip_dc=0;
1805
        threshold= -threshold;
1806 c9178d86 Michael Niedermayer
    }else
1807
        skip_dc=1;
1808 f5866a03 Michael Niedermayer
1809 7f2fe444 Michael Niedermayer
    /* are all which we could set to zero are allready zero? */
1810
    if(last_index<=skip_dc - 1) return;
1811
1812
    for(i=0; i<=last_index; i++){
1813 2ad1516a Michael Niedermayer
        const int j = s->intra_scantable.permutated[i];
1814 7f2fe444 Michael Niedermayer
        const int level = ABS(block[j]);
1815
        if(level==1){
1816
            if(skip_dc && i==0) continue;
1817
            score+= tab[run];
1818
            run=0;
1819
        }else if(level>1){
1820
            return;
1821
        }else{
1822
            run++;
1823
        }
1824
    }
1825
    if(score >= threshold) return;
1826
    for(i=skip_dc; i<=last_index; i++){
1827 2ad1516a Michael Niedermayer
        const int j = s->intra_scantable.permutated[i];
1828 7f2fe444 Michael Niedermayer
        block[j]=0;
1829
    }
1830
    if(block[0]) s->block_last_index[n]= 0;
1831
    else         s->block_last_index[n]= -1;
1832
}
1833
1834 d7e9533a Michael Niedermayer
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1835
{
1836
    int i;
1837
    const int maxlevel= s->max_qcoeff;
1838
    const int minlevel= s->min_qcoeff;
1839 2ad1516a Michael Niedermayer
    
1840
    if(s->mb_intra){
1841
        i=1; //skip clipping of intra dc
1842
    }else
1843
        i=0;
1844
    
1845
    for(;i<=last_index; i++){
1846
        const int j= s->intra_scantable.permutated[i];
1847 d7e9533a Michael Niedermayer
        int level = block[j];
1848
       
1849
        if     (level>maxlevel) level=maxlevel;
1850
        else if(level<minlevel) level=minlevel;
1851
        block[j]= level;
1852
    }
1853
}
1854 9dbcbd92 Michael Niedermayer
1855 fcb48651 Michael Niedermayer
static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
1856
{
1857
    int i;
1858 2ad1516a Michael Niedermayer
1859
    if(s->mb_intra){
1860
        i=1; //skip clipping of intra dc
1861
         //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1862 fcb48651 Michael Niedermayer
    }else
1863
        i=0;
1864
    
1865
    for(;i<=s->block_last_index[n]; i++){
1866 2ad1516a Michael Niedermayer
        const int j = s->intra_scantable.permutated[i];
1867 fcb48651 Michael Niedermayer
        int level = block[j];
1868
        
1869
        block[j]= ROUNDED_DIV(level*oldq, newq);
1870
    }
1871
1872
    for(i=s->block_last_index[n]; i>=0; i--){
1873 2ad1516a Michael Niedermayer
        const int j = s->intra_scantable.permutated[i];
1874 fcb48651 Michael Niedermayer
        if(block[j]) break;
1875
    }
1876
    s->block_last_index[n]= i;
1877
}
1878
1879
static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
1880
{
1881
    int i,n, newq;
1882
    const int maxlevel= s->max_qcoeff;
1883
    const int minlevel= s->min_qcoeff;
1884
    int largest=0, smallest=0;
1885
1886
    assert(s->adaptive_quant);
1887
    
1888
    for(n=0; n<6; n++){
1889 2ad1516a Michael Niedermayer
        if(s->mb_intra){
1890
            i=1; //skip clipping of intra dc
1891
             //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1892
        }else
1893
            i=0;
1894 fcb48651 Michael Niedermayer
1895
        for(;i<=s->block_last_index[n]; i++){
1896 2ad1516a Michael Niedermayer
            const int j = s->intra_scantable.permutated[i];
1897 fcb48651 Michael Niedermayer
            int level = block[n][j];
1898
            if(largest  < level) largest = level;
1899
            if(smallest > level) smallest= level;
1900
        }
1901
    }
1902
    
1903
    for(newq=s->qscale+1; newq<32; newq++){
1904
        if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
1905
           && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel) 
1906
            break;
1907
    }
1908
        
1909
    if(s->out_format==FMT_H263){
1910
        /* h263 like formats cannot change qscale by more than 2 easiely */
1911
        if(s->avctx->qmin + 2 < newq)
1912
            newq= s->avctx->qmin + 2;
1913
    }
1914
1915
    for(n=0; n<6; n++){
1916
        requantize_coeffs(s, block[n], s->qscale, newq, n);
1917
        clip_coeffs(s, block[n], s->block_last_index[n]);
1918
    }
1919
     
1920
    s->dquant+= newq - s->qscale;
1921
    s->qscale= newq;
1922
}
1923
#if 0
1924
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1925
    int score=0;
1926
    int x,y;
1927
    
1928
    for(y=0; y<7; y++){
1929
        for(x=0; x<16; x+=4){
1930
            score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
1931
                   +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
1932
        }
1933
        s+= stride;
1934
    }
1935
    
1936
    return score;
1937
}
1938

1939
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1940
    int score=0;
1941
    int x,y;
1942
    
1943
    for(y=0; y<7; y++){
1944
        for(x=0; x<16; x++){
1945
            score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
1946
        }
1947
        s1+= stride;
1948
        s2+= stride;
1949
    }
1950
    
1951
    return score;
1952
}
1953
#else
1954
#define SQ(a) ((a)*(a))
1955
1956
static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1957
    int score=0;
1958
    int x,y;
1959
    
1960
    for(y=0; y<7; y++){
1961
        for(x=0; x<16; x+=4){
1962
            score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
1963
                   +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
1964
        }
1965
        s+= stride;
1966
    }
1967
    
1968
    return score;
1969
}
1970
1971
static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1972
    int score=0;
1973
    int x,y;
1974
    
1975
    for(y=0; y<7; y++){
1976
        for(x=0; x<16; x++){
1977
            score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
1978
        }
1979
        s1+= stride;
1980
        s2+= stride;
1981
    }
1982
    
1983
    return score;
1984
}
1985
1986
#endif
1987 9dbcbd92 Michael Niedermayer
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
1988 de6d9b64 Fabrice Bellard
{
1989 ba6802de Michael Niedermayer
    const int mb_x= s->mb_x;
1990
    const int mb_y= s->mb_y;
1991
    int i;
1992 7f2fe444 Michael Niedermayer
    int skip_dct[6];
1993 fcb48651 Michael Niedermayer
    int dct_offset   = s->linesize*8; //default for progressive frames
1994
    
1995 7f2fe444 Michael Niedermayer
    for(i=0; i<6; i++) skip_dct[i]=0;
1996 c5d309f2 Michael Niedermayer
    
1997
    if(s->adaptive_quant){
1998
        s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
1999 fcb48651 Michael Niedermayer
2000
        if(s->out_format==FMT_H263){
2001 c5d309f2 Michael Niedermayer
            if     (s->dquant> 2) s->dquant= 2;
2002
            else if(s->dquant<-2) s->dquant=-2;
2003 fcb48651 Michael Niedermayer
        }
2004
            
2005
        if(s->codec_id==CODEC_ID_MPEG4){        
2006 c5d309f2 Michael Niedermayer
            if(!s->mb_intra){
2007
                assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2008
2009
                if(s->mv_dir&MV_DIRECT)
2010
                    s->dquant=0;
2011
            }
2012
        }
2013
        s->qscale+= s->dquant;
2014
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2015
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2016
    }
2017 ba6802de Michael Niedermayer
2018 9dbcbd92 Michael Niedermayer
    if (s->mb_intra) {
2019
        UINT8 *ptr;
2020 fcb48651 Michael Niedermayer
        int wrap_y;
2021 79c0c785 Michael Niedermayer
        int emu=0;
2022 9dbcbd92 Michael Niedermayer
2023 fcb48651 Michael Niedermayer
        wrap_y = s->linesize;
2024
        ptr = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2025
2026 79c0c785 Michael Niedermayer
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2027 fcb48651 Michael Niedermayer
            emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2028 79c0c785 Michael Niedermayer
            ptr= s->edge_emu_buffer;
2029
            emu=1;
2030
        }
2031 fcb48651 Michael Niedermayer
        
2032
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2033
            int progressive_score, interlaced_score;
2034
            
2035
            progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2036
            interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2037
            
2038
            if(progressive_score > interlaced_score + 100){
2039
                s->interlaced_dct=1;
2040
            
2041
                dct_offset= wrap_y;
2042
                wrap_y<<=1;
2043
            }else
2044
                s->interlaced_dct=0;
2045
        }
2046
        
2047
        get_pixels(s->block[0], ptr                 , wrap_y);
2048
        get_pixels(s->block[1], ptr              + 8, wrap_y);
2049
        get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2050
        get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2051 9dbcbd92 Michael Niedermayer
2052 6282185e Michael Niedermayer
        if(s->flags&CODEC_FLAG_GRAY){
2053
            skip_dct[4]= 1;
2054
            skip_dct[5]= 1;
2055
        }else{
2056 fcb48651 Michael Niedermayer
            int wrap_c = s->uvlinesize;
2057
            ptr = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2058 79c0c785 Michael Niedermayer
            if(emu){
2059 fcb48651 Michael Niedermayer
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2060 79c0c785 Michael Niedermayer
                ptr= s->edge_emu_buffer;
2061
            }
2062 fcb48651 Michael Niedermayer
            get_pixels(s->block[4], ptr, wrap_c);
2063 9dbcbd92 Michael Niedermayer
2064 fcb48651 Michael Niedermayer
            ptr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2065 79c0c785 Michael Niedermayer
            if(emu){
2066 fcb48651 Michael Niedermayer
                emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2067 79c0c785 Michael Niedermayer
                ptr= s->edge_emu_buffer;
2068
            }
2069 fcb48651 Michael Niedermayer
            get_pixels(s->block[5], ptr, wrap_c);
2070 6282185e Michael Niedermayer
        }
2071 9dbcbd92 Michael Niedermayer
    }else{
2072 b3184779 Michael Niedermayer
        op_pixels_func (*op_pix)[4];
2073
        qpel_mc_func (*op_qpix)[16];
2074 9dbcbd92 Michael Niedermayer
        UINT8 *dest_y, *dest_cb, *dest_cr;
2075 7f2fe444 Michael Niedermayer
        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2076
        int wrap_y, wrap_c;
2077 79c0c785 Michael Niedermayer
        int emu=0;
2078 9dbcbd92 Michael Niedermayer
2079
        dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
2080 0fd90455 Michael Niedermayer
        dest_cb = s->current_picture[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2081
        dest_cr = s->current_picture[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2082 7f2fe444 Michael Niedermayer
        wrap_y = s->linesize;
2083 fcb48651 Michael Niedermayer
        wrap_c = s->uvlinesize;
2084 7f2fe444 Michael Niedermayer
        ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2085
        ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2086
        ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2087 9dbcbd92 Michael Niedermayer
2088 91029be7 Michael Niedermayer
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
2089 9dbcbd92 Michael Niedermayer
            op_pix = put_pixels_tab;
2090 b3184779 Michael Niedermayer
            op_qpix= put_qpel_pixels_tab;
2091 cf8039b2 Michael Niedermayer
        }else{
2092 9dbcbd92 Michael Niedermayer
            op_pix = put_no_rnd_pixels_tab;
2093 b3184779 Michael Niedermayer
            op_qpix= put_no_rnd_qpel_pixels_tab;
2094 9dbcbd92 Michael Niedermayer
        }
2095
2096
        if (s->mv_dir & MV_DIR_FORWARD) {
2097
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
2098 b3184779 Michael Niedermayer
            op_pix = avg_pixels_tab;
2099
            op_qpix= avg_qpel_pixels_tab;
2100 9dbcbd92 Michael Niedermayer
        }
2101
        if (s->mv_dir & MV_DIR_BACKWARD) {
2102
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
2103 ba6802de Michael Niedermayer
        }
2104 9dbcbd92 Michael Niedermayer
2105 79c0c785 Michael Niedermayer
        if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2106
            emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2107
            ptr_y= s->edge_emu_buffer;
2108
            emu=1;
2109
        }
2110 fcb48651 Michael Niedermayer
        
2111
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2112
            int progressive_score, interlaced_score;
2113
            
2114
            progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  ) 
2115
                             + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2116
            interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2117
                             + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2118
            
2119
            if(progressive_score > interlaced_score + 600){
2120
                s->interlaced_dct=1;
2121
            
2122
                dct_offset= wrap_y;
2123
                wrap_y<<=1;
2124
            }else
2125
                s->interlaced_dct=0;
2126
        }
2127
        
2128 7f2fe444 Michael Niedermayer
        diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2129
        diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2130 fcb48651 Michael Niedermayer
        diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2131
        diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2132 6282185e Michael Niedermayer
        
2133
        if(s->flags&CODEC_FLAG_GRAY){
2134
            skip_dct[4]= 1;
2135
            skip_dct[5]= 1;
2136
        }else{
2137 79c0c785 Michael Niedermayer
            if(emu){
2138
                emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2139
                ptr_cb= s->edge_emu_buffer;
2140
            }
2141 6282185e Michael Niedermayer
            diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2142 79c0c785 Michael Niedermayer
            if(emu){
2143
                emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2144
                ptr_cr= s->edge_emu_buffer;
2145
            }
2146 6282185e Michael Niedermayer
            diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2147
        }
2148
2149 7f2fe444 Michael Niedermayer
        /* pre quantization */         
2150
        if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2151 fcb48651 Michael Niedermayer
            //FIXME optimize
2152 7f2fe444 Michael Niedermayer
            if(pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2153
            if(pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2154 fcb48651 Michael Niedermayer
            if(pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2155
            if(pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2156 7f2fe444 Michael Niedermayer
            if(pix_abs8x8(ptr_cb              , dest_cb              , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
2157
            if(pix_abs8x8(ptr_cr              , dest_cr              , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
2158
#if 0
2159
{
2160
 static int stat[7];
2161
 int num=0;
2162
 for(i=0; i<6; i++)
2163
  if(skip_dct[i]) num++;
2164
 stat[num]++;
2165
 
2166
 if(s->mb_x==0 && s->mb_y==0){
2167
  for(i=0; i<7; i++){
2168
   printf("%6d %1d\n", stat[i], i);
2169
  }
2170
 }
2171
}
2172
#endif
2173
        }
2174 9dbcbd92 Michael Niedermayer
2175 ba6802de Michael Niedermayer
    }
2176
            
2177
#if 0
2178
            {
2179
                float adap_parm;
2180
                
2181
                adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2182
                            ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2183
            
2184
                printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
2185
                        (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
2186
                        s->qscale, adap_parm, s->qscale*adap_parm,
2187
                        s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2188
            }
2189
#endif
2190
    /* DCT & quantize */
2191 d7e9533a Michael Niedermayer
    if(s->out_format==FMT_MJPEG){
2192
        for(i=0;i<6;i++) {
2193
            int overflow;
2194 28db7fce Michael Niedermayer
            s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2195 ef5b1b5a Juanjo
            if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2196 d7e9533a Michael Niedermayer
        }
2197
    }else{
2198
        for(i=0;i<6;i++) {
2199 7f2fe444 Michael Niedermayer
            if(!skip_dct[i]){
2200
                int overflow;
2201 28db7fce Michael Niedermayer
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2202 d7e9533a Michael Niedermayer
            // FIXME we could decide to change to quantizer instead of clipping
2203 ef5b1b5a Juanjo
            // JS: I don't think that would be a good idea it could lower quality instead
2204
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
2205 7f2fe444 Michael Niedermayer
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2206
            }else
2207
                s->block_last_index[i]= -1;
2208 d7e9533a Michael Niedermayer
        }
2209 7f2fe444 Michael Niedermayer
        if(s->luma_elim_threshold && !s->mb_intra)
2210
            for(i=0; i<4; i++)
2211 c9178d86 Michael Niedermayer
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2212 7f2fe444 Michael Niedermayer
        if(s->chroma_elim_threshold && !s->mb_intra)
2213
            for(i=4; i<6; i++)
2214 c9178d86 Michael Niedermayer
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2215 ba6802de Michael Niedermayer
    }
2216
2217 6282185e Michael Niedermayer
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2218
        s->block_last_index[4]=
2219
        s->block_last_index[5]= 0;
2220
        s->block[4][0]=
2221
        s->block[5][0]= 128;
2222
    }
2223
2224 ba6802de Michael Niedermayer
    /* huffman encode */
2225
    switch(s->out_format) {
2226
    case FMT_MPEG1:
2227
        mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2228
        break;
2229
    case FMT_H263:
2230
        if (s->h263_msmpeg4)
2231
            msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2232
        else if(s->h263_pred)
2233
            mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2234
        else
2235
            h263_encode_mb(s, s->block, motion_x, motion_y);
2236
        break;
2237
    case FMT_MJPEG:
2238
        mjpeg_encode_mb(s, s->block);
2239
        break;
2240
    }
2241
}
2242
2243 7f2fe444 Michael Niedermayer
void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2244 ba6802de Michael Niedermayer
{
2245 1f0cd30f Michael Niedermayer
    int bytes= length>>4;
2246
    int bits= length&15;
2247
    int i;
2248
2249 7f2fe444 Michael Niedermayer
    if(length==0) return;
2250
2251 1f0cd30f Michael Niedermayer
    for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2252
    put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2253 ba6802de Michael Niedermayer
}
2254
2255 7f2fe444 Michael Niedermayer
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2256 1f0cd30f Michael Niedermayer
    int i;
2257
2258
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2259
2260
    /* mpeg1 */
2261
    d->mb_incr= s->mb_incr;
2262
    for(i=0; i<3; i++)
2263
        d->last_dc[i]= s->last_dc[i];
2264
    
2265
    /* statistics */
2266
    d->mv_bits= s->mv_bits;
2267
    d->i_tex_bits= s->i_tex_bits;
2268
    d->p_tex_bits= s->p_tex_bits;
2269
    d->i_count= s->i_count;
2270 66370d3f Michael Niedermayer
    d->f_count= s->f_count;
2271
    d->b_count= s->b_count;
2272 1f0cd30f Michael Niedermayer
    d->skip_count= s->skip_count;
2273
    d->misc_bits= s->misc_bits;
2274 8b4c7dbc Michael Niedermayer
    d->last_bits= 0;
2275 91029be7 Michael Niedermayer
2276
    d->mb_skiped= s->mb_skiped;
2277 1f0cd30f Michael Niedermayer
}
2278
2279 7f2fe444 Michael Niedermayer
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2280 1f0cd30f Michael Niedermayer
    int i;
2281
2282
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2283
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2284
    
2285
    /* mpeg1 */
2286
    d->mb_incr= s->mb_incr;
2287
    for(i=0; i<3; i++)
2288
        d->last_dc[i]= s->last_dc[i];
2289
    
2290
    /* statistics */
2291
    d->mv_bits= s->mv_bits;
2292
    d->i_tex_bits= s->i_tex_bits;
2293
    d->p_tex_bits= s->p_tex_bits;
2294
    d->i_count= s->i_count;
2295 66370d3f Michael Niedermayer
    d->f_count= s->f_count;
2296
    d->b_count= s->b_count;
2297 1f0cd30f Michael Niedermayer
    d->skip_count= s->skip_count;
2298
    d->misc_bits= s->misc_bits;
2299
2300
    d->mb_intra= s->mb_intra;
2301 91029be7 Michael Niedermayer
    d->mb_skiped= s->mb_skiped;
2302 1f0cd30f Michael Niedermayer
    d->mv_type= s->mv_type;
2303
    d->mv_dir= s->mv_dir;
2304
    d->pb= s->pb;
2305 7f2fe444 Michael Niedermayer
    if(s->data_partitioning){
2306
        d->pb2= s->pb2;
2307
        d->tex_pb= s->tex_pb;
2308
    }
2309 1f0cd30f Michael Niedermayer
    d->block= s->block;
2310
    for(i=0; i<6; i++)
2311
        d->block_last_index[i]= s->block_last_index[i];
2312
}
2313
2314 7f2fe444 Michael Niedermayer
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2315
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2316
                           int *dmin, int *next_block, int motion_x, int motion_y)
2317
{
2318
    int bits_count;
2319
    
2320
    copy_context_before_encode(s, backup, type);
2321
2322
    s->block= s->blocks[*next_block];
2323
    s->pb= pb[*next_block];
2324
    if(s->data_partitioning){
2325
        s->pb2   = pb2   [*next_block];
2326
        s->tex_pb= tex_pb[*next_block];
2327
    }
2328
2329
    encode_mb(s, motion_x, motion_y);
2330
2331
    bits_count= get_bit_count(&s->pb);
2332
    if(s->data_partitioning){
2333
        bits_count+= get_bit_count(&s->pb2);
2334
        bits_count+= get_bit_count(&s->tex_pb);
2335
    }
2336
2337
    if(bits_count<*dmin){
2338
        *dmin= bits_count;
2339
        *next_block^=1;
2340
2341
        copy_context_after_encode(best, s, type);
2342
    }
2343
}
2344 1f0cd30f Michael Niedermayer
2345 ba6802de Michael Niedermayer
static void encode_picture(MpegEncContext *s, int picture_number)
2346
{
2347
    int mb_x, mb_y, last_gob, pdif = 0;
2348
    int i;
2349 098eefe1 Michael Niedermayer
    int bits;
2350 1f0cd30f Michael Niedermayer
    MpegEncContext best_s, backup_s;
2351 7f2fe444 Michael Niedermayer
    UINT8 bit_buf[2][3000];
2352
    UINT8 bit_buf2[2][3000];
2353
    UINT8 bit_buf_tex[2][3000];
2354
    PutBitContext pb[2], pb2[2], tex_pb[2];
2355
2356
    for(i=0; i<2; i++){
2357
        init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2358
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2359
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2360
    }
2361 de6d9b64 Fabrice Bellard
2362
    s->picture_number = picture_number;
2363 9cdd6a24 Michael Niedermayer
2364 ba6802de Michael Niedermayer
    s->block_wrap[0]=
2365
    s->block_wrap[1]=
2366
    s->block_wrap[2]=
2367
    s->block_wrap[3]= s->mb_width*2 + 2;
2368
    s->block_wrap[4]=
2369
    s->block_wrap[5]= s->mb_width + 2;
2370
    
2371 9cdd6a24 Michael Niedermayer
    /* Reset the average MB variance */
2372 7f2fe444 Michael Niedermayer
    s->mb_var_sum = 0;
2373
    s->mc_mb_var_sum = 0;
2374 91029be7 Michael Niedermayer
2375
    /* we need to initialize some time vars before we can encode b-frames */
2376
    if (s->h263_pred && !s->h263_msmpeg4)
2377
        ff_set_mpeg4_time(s, s->picture_number); 
2378
2379 1fb4890b Michael Niedermayer
    s->scene_change_score=0;
2380 c5d309f2 Michael Niedermayer
    
2381
    s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2382 1fb4890b Michael Niedermayer
2383 9cdd6a24 Michael Niedermayer
    /* Estimate motion for every MB */
2384 9dbcbd92 Michael Niedermayer
    if(s->pict_type != I_TYPE){
2385 ba6802de Michael Niedermayer
        for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2386
            s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2387
            s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2388
            s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2389
            s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2390
            for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2391
                s->mb_x = mb_x;
2392
                s->mb_y = mb_y;
2393
                s->block_index[0]+=2;
2394
                s->block_index[1]+=2;
2395
                s->block_index[2]+=2;
2396
                s->block_index[3]+=2;
2397
2398
                /* compute motion vector & mb_type and store in context */
2399 9dbcbd92 Michael Niedermayer
                if(s->pict_type==B_TYPE)
2400
                    ff_estimate_b_frame_motion(s, mb_x, mb_y);
2401
                else
2402
                    ff_estimate_p_frame_motion(s, mb_x, mb_y);
2403 ba6802de Michael Niedermayer
//                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2404 9cdd6a24 Michael Niedermayer
            }
2405
        }
2406 ba6802de Michael Niedermayer
        emms_c();
2407 7f2fe444 Michael Niedermayer
    }else /* if(s->pict_type == I_TYPE) */{
2408 ba6802de Michael Niedermayer
        /* I-Frame */
2409
        //FIXME do we need to zero them?
2410
        memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2411 9dbcbd92 Michael Niedermayer
        memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2412 ba6802de Michael Niedermayer
        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2413 3aa102be Michael Niedermayer
        
2414
        if(!s->fixed_qscale){
2415
            /* finding spatial complexity for I-frame rate control */
2416
            for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2417
                for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2418
                    int xx = mb_x * 16;
2419
                    int yy = mb_y * 16;
2420
                    uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
2421
                    int varc;
2422
                    int sum = pix_sum(pix, s->linesize);
2423
    
2424
                    sum= (sum+8)>>4;
2425
                    varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
2426
2427 c5d309f2 Michael Niedermayer
                    s->mb_var [s->mb_width * mb_y + mb_x] = varc;
2428
                    s->mb_mean[s->mb_width * mb_y + mb_x] = (sum+7)>>4;
2429 3aa102be Michael Niedermayer
                    s->mb_var_sum    += varc;
2430
                }
2431
            }
2432
        }
2433 9cdd6a24 Michael Niedermayer
    }
2434 1fb4890b Michael Niedermayer
    if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2435 bd31a775 Michael Niedermayer
        s->pict_type= I_TYPE;
2436 ba6802de Michael Niedermayer
        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2437 8b4c7dbc Michael Niedermayer
        if(s->max_b_frames==0){
2438
            s->input_pict_type= I_TYPE;
2439
            s->input_picture_in_gop_number=0;
2440
        }
2441 3aa102be Michael Niedermayer
//printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
2442 bd31a775 Michael Niedermayer
    }
2443 9dbcbd92 Michael Niedermayer
    
2444
    if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2445
        s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2446
        ff_fix_long_p_mvs(s);
2447
    if(s->pict_type==B_TYPE){
2448
        s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2449
        s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2450 91029be7 Michael Niedermayer
2451
        ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2452
        ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2453
        ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2454
        ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2455 45870f57 Michael Niedermayer
    }
2456 9dbcbd92 Michael Niedermayer
    
2457 c5d309f2 Michael Niedermayer
    if (s->fixed_qscale) 
2458
        s->frame_qscale = s->avctx->quality;
2459
    else
2460
        s->frame_qscale = ff_rate_estimate_qscale(s);
2461 8b4c7dbc Michael Niedermayer
2462 9e4c6948 Michael Niedermayer
    if(s->adaptive_quant){
2463
        switch(s->codec_id){
2464
        case CODEC_ID_MPEG4:
2465
            ff_clean_mpeg4_qscales(s);
2466
            break;
2467
        case CODEC_ID_H263:
2468
        case CODEC_ID_H263P:
2469
            ff_clean_h263_qscales(s);
2470
            break;
2471
        }
2472
2473 c5d309f2 Michael Niedermayer
        s->qscale= s->qscale_table[0];
2474 9e4c6948 Michael Niedermayer
    }else
2475 c5d309f2 Michael Niedermayer
        s->qscale= (int)(s->frame_qscale + 0.5);
2476
        
2477 de6d9b64 Fabrice Bellard
    if (s->out_format == FMT_MJPEG) {
2478
        /* for mjpeg, we do include qscale in the matrix */
2479 adc09b2e Marko Kreen
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2480 2ad1516a Michael Niedermayer
        for(i=1;i<64;i++){
2481
            int j= s->idct_permutation[i];
2482
2483
            s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2484
        }
2485 28db7fce Michael Niedermayer
        convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2486 cc7ac888 Michael Niedermayer
                       s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2487 de6d9b64 Fabrice Bellard
    }
2488
2489 098eefe1 Michael Niedermayer
    s->last_bits= get_bit_count(&s->pb);
2490 de6d9b64 Fabrice Bellard
    switch(s->out_format) {
2491
    case FMT_MJPEG:
2492
        mjpeg_picture_header(s);
2493
        break;
2494
    case FMT_H263:
2495
        if (s->h263_msmpeg4) 
2496
            msmpeg4_encode_picture_header(s, picture_number);
2497
        else if (s->h263_pred)
2498
            mpeg4_encode_picture_header(s, picture_number);
2499
        else if (s->h263_rv10) 
2500
            rv10_encode_picture_header(s, picture_number);
2501
        else
2502
            h263_encode_picture_header(s, picture_number);
2503
        break;
2504
    case FMT_MPEG1:
2505
        mpeg1_encode_picture_header(s, picture_number);
2506
        break;
2507
    }
2508 098eefe1 Michael Niedermayer
    bits= get_bit_count(&s->pb);
2509
    s->header_bits= bits - s->last_bits;
2510
    s->last_bits= bits;
2511
    s->mv_bits=0;
2512
    s->misc_bits=0;
2513
    s->i_tex_bits=0;
2514
    s->p_tex_bits=0;
2515
    s->i_count=0;
2516 66370d3f Michael Niedermayer
    s->f_count=0;
2517
    s->b_count=0;
2518 098eefe1 Michael Niedermayer
    s->skip_count=0;
2519
2520 de6d9b64 Fabrice Bellard
    /* init last dc values */
2521
    /* note: quant matrix value (8) is implied here */
2522
    s->last_dc[0] = 128;
2523
    s->last_dc[1] = 128;
2524
    s->last_dc[2] = 128;
2525
    s->mb_incr = 1;
2526
    s->last_mv[0][0][0] = 0;
2527
    s->last_mv[0][0][1] = 0;
2528
2529 644d98a4 Juanjo
    /* Get the GOB height based on picture height */
2530 81401c1f Juanjo
    if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
2531 644d98a4 Juanjo
        if (s->height <= 400)
2532
            s->gob_index = 1;
2533
        else if (s->height <= 800)
2534
            s->gob_index = 2;
2535
        else
2536
            s->gob_index = 4;
2537 7f2fe444 Michael Niedermayer
    }else if(s->codec_id==CODEC_ID_MPEG4){
2538
        s->gob_index = 1;
2539 644d98a4 Juanjo
    }
2540 7f2fe444 Michael Niedermayer
2541
    if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2542
        ff_mpeg4_init_partitions(s);
2543
2544
    s->resync_mb_x=0;
2545
    s->resync_mb_y=0;
2546 e03c341e Juanjo
    for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2547 7f2fe444 Michael Niedermayer
        /* Put GOB header based on RTP MTU for formats which support it per line (H263*)*/
2548 e03c341e Juanjo
        /* TODO: Put all this stuff in a separate generic function */
2549
        if (s->rtp_mode) {
2550
            if (!mb_y) {
2551
                s->ptr_lastgob = s->pb.buf;
2552
                s->ptr_last_mb_line = s->pb.buf;
2553
            } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {
2554 7f2fe444 Michael Niedermayer
                // MN: we could move the space check from h263 -> here, as its not h263 specific
2555 e03c341e Juanjo
                last_gob = h263_encode_gob_header(s, mb_y);
2556
                if (last_gob) {
2557 7f2fe444 Michael Niedermayer
                    s->first_slice_line = 1;
2558
                }else{
2559
                    /*MN: we reset it here instead at the end of each line cuz mpeg4 can have 
2560
                          slice lines starting & ending in the middle*/
2561
                    s->first_slice_line = 0;
2562 e03c341e Juanjo
                }
2563
            }
2564
        }
2565 f5957f3f Michael Niedermayer
2566
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2567
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2568 e03c341e Juanjo
        
2569 4278e7a6 Michael Niedermayer
        s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2570
        s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2571
        s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2572
        s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2573
        s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2574
        s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2575 37fbfd0a Juanjo
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2576 91029be7 Michael Niedermayer
            const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2577
            const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2578 7f2fe444 Michael Niedermayer
//            int d;
2579 ba6802de Michael Niedermayer
            int dmin=10000000;
2580 37fbfd0a Juanjo
2581
            s->mb_x = mb_x;
2582
            s->mb_y = mb_y;
2583 4278e7a6 Michael Niedermayer
            s->block_index[0]+=2;
2584
            s->block_index[1]+=2;
2585
            s->block_index[2]+=2;
2586
            s->block_index[3]+=2;
2587
            s->block_index[4]++;
2588
            s->block_index[5]++;
2589 7f2fe444 Michael Niedermayer
            
2590
            /* write gob / video packet header for formats which support it at any MB (MPEG4) */
2591
            if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
2592
                int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
2593
2594
                //the *2 is there so we stay below the requested size
2595
                if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){ 
2596
                    if(s->codec_id==CODEC_ID_MPEG4){
2597
                        if(s->data_partitioning && s->pict_type!=B_TYPE){
2598
                            ff_mpeg4_merge_partitions(s);
2599
                            ff_mpeg4_init_partitions(s);
2600
                        }
2601
                        ff_mpeg4_encode_video_packet_header(s);
2602
2603
                        if(s->flags&CODEC_FLAG_PASS1){
2604
                            int bits= get_bit_count(&s->pb);
2605
                            s->misc_bits+= bits - s->last_bits;
2606
                            s->last_bits= bits;
2607
                        }
2608
                        ff_mpeg4_clean_buffers(s);
2609
                    }
2610
                    s->ptr_lastgob = pbBufPtr(&s->pb);
2611
                    s->first_slice_line=1;
2612
                    s->resync_mb_x=mb_x;
2613
                    s->resync_mb_y=mb_y;
2614
                }
2615
2616
                if(  (s->resync_mb_x   == s->mb_x)
2617
                   && s->resync_mb_y+1 == s->mb_y){
2618
                    s->first_slice_line=0; 
2619
                }
2620
            }
2621
2622 ba6802de Michael Niedermayer
            if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2623 91029be7 Michael Niedermayer
                int next_block=0;
2624 7f2fe444 Michael Niedermayer
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2625 1f0cd30f Michael Niedermayer
2626
                copy_context_before_encode(&backup_s, s, -1);
2627 7f2fe444 Michael Niedermayer
                backup_s.pb= s->pb;
2628
                best_s.data_partitioning= s->data_partitioning;
2629
                if(s->data_partitioning){
2630
                    backup_s.pb2= s->pb2;
2631
                    backup_s.tex_pb= s->tex_pb;
2632
                }
2633 1f0cd30f Michael Niedermayer
2634 ba6802de Michael Niedermayer
                if(mb_type&MB_TYPE_INTER){
2635 91029be7 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD;
2636 cf8039b2 Michael Niedermayer
                    s->mv_type = MV_TYPE_16X16;
2637 ba6802de Michael Niedermayer
                    s->mb_intra= 0;
2638 9dbcbd92 Michael Niedermayer
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
2639
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
2640 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
2641
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2642 de6d9b64 Fabrice Bellard
                }
2643 1f0cd30f Michael Niedermayer
                if(mb_type&MB_TYPE_INTER4V){                 
2644 91029be7 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD;
2645 cf8039b2 Michael Niedermayer
                    s->mv_type = MV_TYPE_8X8;
2646
                    s->mb_intra= 0;
2647
                    for(i=0; i<4; i++){
2648
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2649
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2650
                    }
2651 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
2652
                                 &dmin, &next_block, 0, 0);
2653 91029be7 Michael Niedermayer
                }
2654
                if(mb_type&MB_TYPE_FORWARD){
2655
                    s->mv_dir = MV_DIR_FORWARD;
2656
                    s->mv_type = MV_TYPE_16X16;
2657
                    s->mb_intra= 0;
2658
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2659
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2660 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
2661
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2662 91029be7 Michael Niedermayer
                }
2663
                if(mb_type&MB_TYPE_BACKWARD){
2664
                    s->mv_dir = MV_DIR_BACKWARD;
2665
                    s->mv_type = MV_TYPE_16X16;
2666
                    s->mb_intra= 0;
2667
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2668
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2669 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
2670
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2671 91029be7 Michael Niedermayer
                }
2672
                if(mb_type&MB_TYPE_BIDIR){
2673
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2674
                    s->mv_type = MV_TYPE_16X16;
2675
                    s->mb_intra= 0;
2676
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2677
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2678
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2679
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2680 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
2681
                                 &dmin, &next_block, 0, 0);
2682 91029be7 Michael Niedermayer
                }
2683
                if(mb_type&MB_TYPE_DIRECT){
2684
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2685
                    s->mv_type = MV_TYPE_16X16; //FIXME
2686
                    s->mb_intra= 0;
2687
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2688
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2689
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2690
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2691 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
2692
                                 &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2693 cf8039b2 Michael Niedermayer
                }
2694 ba6802de Michael Niedermayer
                if(mb_type&MB_TYPE_INTRA){
2695 91029be7 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD;
2696 cf8039b2 Michael Niedermayer
                    s->mv_type = MV_TYPE_16X16;
2697 ba6802de Michael Niedermayer
                    s->mb_intra= 1;
2698
                    s->mv[0][0][0] = 0;
2699
                    s->mv[0][0][1] = 0;
2700 7f2fe444 Michael Niedermayer
                    encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
2701
                                 &dmin, &next_block, 0, 0);
2702 1f0cd30f Michael Niedermayer
                    /* force cleaning of ac/dc pred stuff if needed ... */
2703
                    if(s->h263_pred || s->h263_aic)
2704
                        s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2705 cf8039b2 Michael Niedermayer
                }
2706 1f0cd30f Michael Niedermayer
                copy_context_after_encode(s, &best_s, -1);
2707 7f2fe444 Michael Niedermayer
                
2708
                pb_bits_count= get_bit_count(&s->pb);
2709
                flush_put_bits(&s->pb);
2710
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2711
                s->pb= backup_s.pb;
2712
                
2713
                if(s->data_partitioning){
2714
                    pb2_bits_count= get_bit_count(&s->pb2);
2715
                    flush_put_bits(&s->pb2);
2716
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2717
                    s->pb2= backup_s.pb2;
2718
                    
2719
                    tex_pb_bits_count= get_bit_count(&s->tex_pb);
2720
                    flush_put_bits(&s->tex_pb);
2721
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2722
                    s->tex_pb= backup_s.tex_pb;
2723
                }
2724 8b4c7dbc Michael Niedermayer
                s->last_bits= get_bit_count(&s->pb);
2725 de6d9b64 Fabrice Bellard
            } else {
2726 9dbcbd92 Michael Niedermayer
                int motion_x, motion_y;
2727
                s->mv_type=MV_TYPE_16X16;
2728 ba6802de Michael Niedermayer
                // only one MB-Type possible
2729 91029be7 Michael Niedermayer
                switch(mb_type){
2730
                case MB_TYPE_INTRA:
2731 9dbcbd92 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD;
2732 ba6802de Michael Niedermayer
                    s->mb_intra= 1;
2733 9dbcbd92 Michael Niedermayer
                    motion_x= s->mv[0][0][0] = 0;
2734
                    motion_y= s->mv[0][0][1] = 0;
2735 91029be7 Michael Niedermayer
                    break;
2736
                case MB_TYPE_INTER:
2737 9dbcbd92 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD;
2738
                    s->mb_intra= 0;
2739
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2740
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2741 91029be7 Michael Niedermayer
                    break;
2742 7f2fe444 Michael Niedermayer
                case MB_TYPE_INTER4V:
2743
                    s->mv_dir = MV_DIR_FORWARD;
2744
                    s->mv_type = MV_TYPE_8X8;
2745
                    s->mb_intra= 0;
2746
                    for(i=0; i<4; i++){
2747
                        s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2748
                        s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2749
                    }
2750
                    motion_x= motion_y= 0;
2751
                    break;
2752 91029be7 Michael Niedermayer
                case MB_TYPE_DIRECT:
2753 9dbcbd92 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2754
                    s->mb_intra= 0;
2755 91029be7 Michael Niedermayer
                    motion_x=s->b_direct_mv_table[xy][0];
2756
                    motion_y=s->b_direct_mv_table[xy][1];
2757
                    s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2758
                    s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2759
                    s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2760
                    s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2761
                    break;
2762
                case MB_TYPE_BIDIR:
2763 9dbcbd92 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2764 ba6802de Michael Niedermayer
                    s->mb_intra= 0;
2765 9dbcbd92 Michael Niedermayer
                    motion_x=0;
2766
                    motion_y=0;
2767
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2768
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2769
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2770
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2771 91029be7 Michael Niedermayer
                    break;
2772
                case MB_TYPE_BACKWARD:
2773 9dbcbd92 Michael Niedermayer
                    s->mv_dir = MV_DIR_BACKWARD;
2774
                    s->mb_intra= 0;
2775
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2776
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2777 91029be7 Michael Niedermayer
                    break;
2778
                case MB_TYPE_FORWARD:
2779 9dbcbd92 Michael Niedermayer
                    s->mv_dir = MV_DIR_FORWARD;
2780
                    s->mb_intra= 0;
2781
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2782
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2783
//                    printf(" %d %d ", motion_x, motion_y);
2784 91029be7 Michael Niedermayer
                    break;
2785
                default:
2786 9dbcbd92 Michael Niedermayer
                    motion_x=motion_y=0; //gcc warning fix
2787
                    printf("illegal MB type\n");
2788 ba6802de Michael Niedermayer
                }
2789 9dbcbd92 Michael Niedermayer
                encode_mb(s, motion_x, motion_y);
2790 de6d9b64 Fabrice Bellard
            }
2791 91029be7 Michael Niedermayer
            /* clean the MV table in IPS frames for direct mode in B frames */
2792
            if(s->mb_intra /* && I,P,S_TYPE */){
2793
                s->p_mv_table[xy][0]=0;
2794
                s->p_mv_table[xy][1]=0;
2795
            }
2796 de6d9b64 Fabrice Bellard
2797 21af69f7 Fabrice Bellard
            MPV_decode_mb(s, s->block);
2798 7f2fe444 Michael Niedermayer
//printf("MB %