* headers valid for C++ compilers
[libav.git] / libavcodec / mpegvideo.c
CommitLineData
de6d9b64
FB
1/*
2 * The simplest mpeg encoder (well, it was the simplest!)
ff4ec49e 3 * Copyright (c) 2000,2001 Fabrice Bellard.
de6d9b64 4 *
ff4ec49e
FB
5 * 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.
de6d9b64 9 *
ff4ec49e 10 * This library is distributed in the hope that it will be useful,
de6d9b64 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
de6d9b64 14 *
ff4ec49e
FB
15 * 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
cf8039b2 18 *
9dbf1ddd 19 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
de6d9b64 20 */
202ef8b8
MN
21
22#include <ctype.h>
f943e138 23#include <limits.h>
de6d9b64
FB
24#include "avcodec.h"
25#include "dsputil.h"
26#include "mpegvideo.h"
2ad1516a 27#include "simple_idct.h"
de6d9b64 28
54329dd5
NK
29#ifdef USE_FASTMEMCPY
30#include "fastmemcpy.h"
31#endif
32
2ad1516a
MN
33//#undef NDEBUG
34//#include <assert.h>
35
21af69f7 36static void encode_picture(MpegEncContext *s, int picture_number);
21af69f7
FB
37static void dct_unquantize_mpeg1_c(MpegEncContext *s,
38 DCTELEM *block, int n, int qscale);
9dbf1ddd
MN
39static void dct_unquantize_mpeg2_c(MpegEncContext *s,
40 DCTELEM *block, int n, int qscale);
21af69f7
FB
41static void dct_unquantize_h263_c(MpegEncContext *s,
42 DCTELEM *block, int n, int qscale);
3d9fccbf 43static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
d7e9533a 44static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
477ab036 45static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
3d9fccbf
MN
46
47void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
48
de6d9b64
FB
49
50/* enable all paranoid tests for rounding, overflows, etc... */
51//#define PARANOID
52
53//#define DEBUG
54
101bea5f 55
de6d9b64
FB
56/* for jpeg fast DCT */
57#define CONST_BITS 14
58
eb4b3dd3 59static const uint16_t aanscales[64] = {
de6d9b64
FB
60 /* precomputed values scaled up by 14 bits */
61 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
62 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
63 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
64 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
65 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
66 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
1457ab52
MN
67 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
68 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
de6d9b64
FB
69};
70
50eb9cbc 71/* Input permutation for the simple_idct_mmx */
eb4b3dd3 72static const uint8_t simple_mmx_permutation[64]={
50eb9cbc
MN
73 0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
74 0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
75 0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
76 0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
77 0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
78 0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
79 0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
80 0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
81};
82
eb4b3dd3 83static const uint8_t h263_chroma_roundtab[16] = {
67725183 84// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
de6d9b64
FB
85 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
86};
87
bbed9259 88static UINT16 (*default_mv_penalty)[MAX_MV*2+1]=NULL;
45870f57
MN
89static UINT8 default_fcode_tab[MAX_MV*2+1];
90
a33c7159
MN
91enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
92
28db7fce 93static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
cc7ac888 94 const UINT16 *quant_matrix, int bias, int qmin, int qmax)
de6d9b64 95{
d7e9533a
MN
96 int qscale;
97
cc7ac888 98 for(qscale=qmin; qscale<=qmax; qscale++){
d7e9533a 99 int i;
28db7fce
MN
100 if (s->fdct == ff_jpeg_fdct_islow) {
101 for(i=0;i<64;i++) {
2ad1516a 102 const int j= s->idct_permutation[i];
28db7fce
MN
103 /* 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
7801d21d 108 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
28db7fce
MN
109 (qscale * quant_matrix[j]));
110 }
111 } else if (s->fdct == fdct_ifast) {
d7e9533a 112 for(i=0;i<64;i++) {
2ad1516a 113 const int j= s->idct_permutation[i];
d7e9533a
MN
114 /* 16 <= qscale * quant_matrix[i] <= 7905 */
115 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
116 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
117 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
118
7801d21d 119 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
d7e9533a
MN
120 (aanscales[i] * qscale * quant_matrix[j]));
121 }
122 } else {
123 for(i=0;i<64;i++) {
2ad1516a 124 const int j= s->idct_permutation[i];
d7e9533a
MN
125 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
126 So 16 <= qscale * quant_matrix[i] <= 7905
127 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
128 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
129 */
477ab036
MN
130 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
131// qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
2ad1516a 132 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
d7e9533a
MN
133
134 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
d7e9533a
MN
135 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
136 }
de6d9b64
FB
137 }
138 }
139}
7f2fe444
MN
140// move into common.c perhaps
141#define CHECKED_ALLOCZ(p, size)\
142{\
143 p= av_mallocz(size);\
144 if(p==NULL){\
145 perror("malloc");\
146 goto fail;\
147 }\
148}
4d2858de 149
2ad1516a
MN
150void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
151 int i;
152 int end;
7801d21d
MN
153
154 st->scantable= src_scantable;
2ad1516a
MN
155
156 for(i=0; i<64; i++){
157 int j;
158 j = src_scantable[i];
159 st->permutated[i] = s->idct_permutation[j];
05c4072b
MN
160#ifdef ARCH_POWERPC
161 st->inverse[j] = i;
162#endif
2ad1516a
MN
163 }
164
165 end=-1;
166 for(i=0; i<64; i++){
167 int j;
168 j = st->permutated[i];
169 if(j>end) end=j;
170 st->raster_end[i]= end;
171 }
172}
173
174/* XXX: those functions should be suppressed ASAP when all IDCTs are
eb4b3dd3
ZK
175 converted */
176// *FIXME* this is ugly hack using local static
177static void (*ff_put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
178static void (*ff_add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
2ad1516a
MN
179static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
180{
181 j_rev_dct (block);
eb4b3dd3 182 ff_put_pixels_clamped(block, dest, line_size);
2ad1516a
MN
183}
184static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
185{
186 j_rev_dct (block);
eb4b3dd3 187 ff_add_pixels_clamped(block, dest, line_size);
2ad1516a 188}
de6d9b64 189
defdfc9a
AB
190/* init common dct for both encoder and decoder */
191int DCT_common_init(MpegEncContext *s)
de6d9b64 192{
defdfc9a 193 int i;
de6d9b64 194
eb4b3dd3
ZK
195 ff_put_pixels_clamped = s->dsp.put_pixels_clamped;
196 ff_add_pixels_clamped = s->dsp.add_pixels_clamped;
197
3bf43d42 198 s->dct_unquantize_h263 = dct_unquantize_h263_c;
9dbf1ddd
MN
199 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
200 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
28db7fce
MN
201 s->dct_quantize= dct_quantize_c;
202
203 if(s->avctx->dct_algo==FF_DCT_FASTINT)
204 s->fdct = fdct_ifast;
205 else
2ad1516a
MN
206 s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
207
208 if(s->avctx->idct_algo==FF_IDCT_INT){
209 s->idct_put= ff_jref_idct_put;
210 s->idct_add= ff_jref_idct_add;
50eb9cbc 211 s->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
2ad1516a
MN
212 }else{ //accurate/default
213 s->idct_put= simple_idct_put;
214 s->idct_add= simple_idct_add;
50eb9cbc 215 s->idct_permutation_type= FF_NO_IDCT_PERM;
2ad1516a 216 }
21af69f7
FB
217
218#ifdef HAVE_MMX
219 MPV_common_init_mmx(s);
a9b3f630 220#endif
e0580f8c
FH
221#ifdef ARCH_ALPHA
222 MPV_common_init_axp(s);
223#endif
c7e07931
MO
224#ifdef HAVE_MLIB
225 MPV_common_init_mlib(s);
226#endif
5917d17c
LS
227#ifdef HAVE_MMI
228 MPV_common_init_mmi(s);
229#endif
676e200c 230#ifdef ARCH_ARMV4L
83f238cb 231 MPV_common_init_armv4l(s);
676e200c 232#endif
05c4072b
MN
233#ifdef ARCH_POWERPC
234 MPV_common_init_ppc(s);
235#endif
676e200c 236
3a87ac94
MN
237 s->fast_dct_quantize= s->dct_quantize;
238
477ab036
MN
239 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
240 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
241 }
242
50eb9cbc
MN
243 switch(s->idct_permutation_type){
244 case FF_NO_IDCT_PERM:
245 for(i=0; i<64; i++)
246 s->idct_permutation[i]= i;
247 break;
248 case FF_LIBMPEG2_IDCT_PERM:
249 for(i=0; i<64; i++)
250 s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
251 break;
252 case FF_SIMPLE_IDCT_PERM:
253 for(i=0; i<64; i++)
254 s->idct_permutation[i]= simple_mmx_permutation[i];
255 break;
256 case FF_TRANSPOSE_IDCT_PERM:
257 for(i=0; i<64; i++)
258 s->idct_permutation[i]= ((i&7)<<3) | (i>>3);
259 break;
260 default:
261 fprintf(stderr, "Internal error, IDCT permutation not set\n");
262 return -1;
263 }
264
2ad1516a
MN
265
266 /* load & permutate scantables
267 note: only wmv uses differnt ones
268 */
269 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
270 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
271 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
272 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
d930ef19 273
defdfc9a
AB
274 return 0;
275}
276
1e491e29 277/**
4e00e76b
MN
278 * allocates a Picture
279 * The pixels are allocated/set by calling get_buffer() if shared=0
1e491e29 280 */
4e00e76b
MN
281static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
282
283 if(shared){
284 assert(pic->data[0]);
285 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
286 pic->type= FF_BUFFER_TYPE_SHARED;
287 }else{
288 int r;
289
290 assert(!pic->data[0]);
291
492cd3a9 292 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
4e00e76b
MN
293
294 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
ef9f7306 295 fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
4e00e76b
MN
296 return -1;
297 }
298
299 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
300 fprintf(stderr, "get_buffer() failed (stride changed)\n");
301 return -1;
302 }
303
304 if(pic->linesize[1] != pic->linesize[2]){
305 fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
306 return -1;
307 }
308
309 s->linesize = pic->linesize[0];
310 s->uvlinesize= pic->linesize[1];
1e491e29 311 }
4e00e76b
MN
312
313 if(pic->qscale_table==NULL){
314 if (s->encoding) {
315 CHECKED_ALLOCZ(pic->mb_var , s->mb_num * sizeof(INT16))
316 CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(INT16))
317 CHECKED_ALLOCZ(pic->mb_mean , s->mb_num * sizeof(INT8))
67725183 318 CHECKED_ALLOCZ(pic->mb_cmp_score, s->mb_num * sizeof(int32_t))
4e00e76b 319 }
1e491e29 320
4e00e76b
MN
321 CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(UINT8)+1) //the +1 is for the slice end check
322 CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(UINT8))
323 pic->qstride= s->mb_width;
324 }
1e491e29 325
f943e138
MN
326 //it might be nicer if the application would keep track of these but it would require a API change
327 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
328 s->prev_pict_types[0]= s->pict_type;
329 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
330 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
331
1e491e29
MN
332 return 0;
333fail: //for the CHECKED_ALLOCZ macro
334 return -1;
335}
336
4e00e76b
MN
337/**
338 * deallocates a picture
339 */
1e491e29
MN
340static void free_picture(MpegEncContext *s, Picture *pic){
341 int i;
4e00e76b
MN
342
343 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
492cd3a9 344 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
4e00e76b
MN
345 }
346
1e491e29
MN
347 av_freep(&pic->mb_var);
348 av_freep(&pic->mc_mb_var);
349 av_freep(&pic->mb_mean);
67725183 350 av_freep(&pic->mb_cmp_score);
1e491e29
MN
351 av_freep(&pic->mbskip_table);
352 av_freep(&pic->qscale_table);
353
4e00e76b 354 if(pic->type == FF_BUFFER_TYPE_INTERNAL){
1e491e29
MN
355 for(i=0; i<4; i++){
356 av_freep(&pic->base[i]);
357 pic->data[i]= NULL;
358 }
359 av_freep(&pic->opaque);
4e00e76b
MN
360 pic->type= 0;
361 }else if(pic->type == FF_BUFFER_TYPE_SHARED){
362 for(i=0; i<4; i++){
363 pic->base[i]=
364 pic->data[i]= NULL;
365 }
366 pic->type= 0;
1e491e29
MN
367 }
368}
369
defdfc9a
AB
370/* init common structure for both encoder and decoder */
371int MPV_common_init(MpegEncContext *s)
372{
8b32880c 373 int y_size, c_size, yc_size, i;
defdfc9a 374
eb4b3dd3 375 dsputil_init(&s->dsp, s->avctx->dsp_mask);
defdfc9a 376 DCT_common_init(s);
eb4b3dd3 377
9fee1e23 378 s->flags= s->avctx->flags;
defdfc9a 379
1e491e29 380 s->mb_width = (s->width + 15) / 16;
de6d9b64 381 s->mb_height = (s->height + 15) / 16;
eb4b3dd3 382
b5a093b3
MN
383 /* set default edge pos, will be overriden in decode_header if needed */
384 s->h_edge_pos= s->mb_width*16;
385 s->v_edge_pos= s->mb_height*16;
eb4b3dd3
ZK
386
387 s->mb_num = s->mb_width * s->mb_height;
388
389 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
390 c_size = (s->mb_width + 2) * (s->mb_height + 2);
391 yc_size = y_size + 2 * c_size;
392
202ef8b8
MN
393 /* convert fourcc to upper case */
394 s->avctx->fourcc= toupper( s->avctx->fourcc &0xFF)
395 + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
396 + (toupper((s->avctx->fourcc>>16)&0xFF)<<16)
397 + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
b5a093b3 398
f7b47594
MN
399 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
400 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
1e491e29 401
492cd3a9 402 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
1e491e29 403
37fbfd0a 404 if (s->encoding) {
9dbcbd92 405 int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
9dbcbd92
MN
406
407 /* Allocate MV tables */
7f2fe444
MN
408 CHECKED_ALLOCZ(s->p_mv_table , mv_table_size * 2 * sizeof(INT16))
409 CHECKED_ALLOCZ(s->b_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
410 CHECKED_ALLOCZ(s->b_back_mv_table , mv_table_size * 2 * sizeof(INT16))
411 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
412 CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
7f2fe444
MN
413 CHECKED_ALLOCZ(s->b_direct_mv_table , mv_table_size * 2 * sizeof(INT16))
414
1e491e29 415 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
1457ab52 416 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t))
7f2fe444 417
1457ab52
MN
418 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
419 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
91029be7 420
7f2fe444
MN
421 if(s->codec_id==CODEC_ID_MPEG4){
422 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
423 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
424 }
3aa102be 425
6b460aa3
MN
426 if(s->msmpeg4_version){
427 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
428 }
3aa102be 429 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
37fbfd0a 430 }
4d2858de
MN
431
432 CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(UINT8))
37fbfd0a 433
174489bd 434 if (s->out_format == FMT_H263 || s->encoding) {
de6d9b64 435 int size;
7f2fe444
MN
436 /* Allocate MB type table */
437 CHECKED_ALLOCZ(s->mb_type , s->mb_num * sizeof(UINT8))
438
de6d9b64
FB
439 /* MV prediction */
440 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
7f2fe444 441 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
bea669e5
MN
442 }
443
444 if(s->codec_id==CODEC_ID_MPEG4){
4d2858de 445 /* interlaced direct mode decoding tables */
bea669e5
MN
446 CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
447 CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
de6d9b64 448 }
4d2858de
MN
449 /* 4mv b frame decoding table */
450 //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
451 CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
6e2d5f1a 452 if (s->out_format == FMT_H263) {
de6d9b64 453 /* ac values */
8b32880c 454 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
de6d9b64
FB
455 s->ac_val[1] = s->ac_val[0] + y_size;
456 s->ac_val[2] = s->ac_val[1] + c_size;
457
458 /* cbp values */
7f2fe444 459 CHECKED_ALLOCZ(s->coded_block, y_size);
eec1c6b9
MN
460
461 /* divx501 bitstream reorder buffer */
7f2fe444 462 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
f01a1894 463
7f2fe444
MN
464 /* cbp, ac_pred, pred_dir */
465 CHECKED_ALLOCZ(s->cbp_table , s->mb_num * sizeof(UINT8))
466 CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
5b3438c6 467 }
8b32880c
MN
468
469 if (s->h263_pred || s->h263_plus || !s->encoding) {
470 /* dc values */
471 //MN: we need these for error resilience of intra-frames
472 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(INT16));
473 s->dc_val[1] = s->dc_val[0] + y_size;
474 s->dc_val[2] = s->dc_val[1] + c_size;
475 for(i=0;i<yc_size;i++)
476 s->dc_val[0][i] = 1024;
477 }
478
7806197d
MN
479 /* which mb is a intra block */
480 CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
481 memset(s->mbintra_table, 1, s->mb_num);
482
de6d9b64
FB
483 /* default structure is frame */
484 s->picture_structure = PICT_FRAME;
93a21abd 485
3bb4e23a 486 /* init macroblock skip table */
4d2858de
MN
487 CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
488 //Note the +1 is for a quicker mpeg4 slice_end detection
f943e138 489 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
ba6802de 490
91029be7 491 s->block= s->blocks[0];
3bb4e23a 492
d7425f59
MN
493 s->parse_context.state= -1;
494
de6d9b64
FB
495 s->context_initialized = 1;
496 return 0;
497 fail:
8257bf05 498 MPV_common_end(s);
de6d9b64
FB
499 return -1;
500}
501
7f2fe444
MN
502
503//extern int sads;
504
de6d9b64
FB
505/* init common structure for both encoder and decoder */
506void MPV_common_end(MpegEncContext *s)
507{
508 int i;
509
6000abfa 510 av_freep(&s->mb_type);
6000abfa 511 av_freep(&s->p_mv_table);
6000abfa
FB
512 av_freep(&s->b_forw_mv_table);
513 av_freep(&s->b_back_mv_table);
514 av_freep(&s->b_bidir_forw_mv_table);
515 av_freep(&s->b_bidir_back_mv_table);
6000abfa
FB
516 av_freep(&s->b_direct_mv_table);
517 av_freep(&s->motion_val);
518 av_freep(&s->dc_val[0]);
519 av_freep(&s->ac_val[0]);
520 av_freep(&s->coded_block);
521 av_freep(&s->mbintra_table);
7f2fe444
MN
522 av_freep(&s->cbp_table);
523 av_freep(&s->pred_dir_table);
1457ab52
MN
524 av_freep(&s->me.scratchpad);
525 av_freep(&s->me.map);
526 av_freep(&s->me.score_map);
7f2fe444 527
6000abfa 528 av_freep(&s->mbskip_table);
f943e138 529 av_freep(&s->prev_pict_types);
6000abfa 530 av_freep(&s->bitstream_buffer);
7f2fe444
MN
531 av_freep(&s->tex_pb_buffer);
532 av_freep(&s->pb2_buffer);
f7b47594 533 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
bea669e5
MN
534 av_freep(&s->co_located_type_table);
535 av_freep(&s->field_mv_table);
536 av_freep(&s->field_select_table);
3aa102be 537 av_freep(&s->avctx->stats_out);
6b460aa3 538 av_freep(&s->ac_stats);
4d2858de 539 av_freep(&s->error_status_table);
1e491e29
MN
540
541 for(i=0; i<MAX_PICTURE_COUNT; i++){
542 free_picture(s, &s->picture[i]);
de6d9b64
FB
543 }
544 s->context_initialized = 0;
545}
546
547/* init video encoder */
548int MPV_encode_init(AVCodecContext *avctx)
549{
550 MpegEncContext *s = avctx->priv_data;
519c2b6d 551 int i;
de6d9b64 552
bc657ac3
ZK
553 avctx->pix_fmt = PIX_FMT_YUV420P;
554
de6d9b64 555 s->bit_rate = avctx->bit_rate;
9cdd6a24 556 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
de6d9b64
FB
557 s->frame_rate = avctx->frame_rate;
558 s->width = avctx->width;
559 s->height = avctx->height;
7f2fe444 560 if(avctx->gop_size > 600){
333547be 561 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
7f2fe444
MN
562 avctx->gop_size=600;
563 }
de6d9b64 564 s->gop_size = avctx->gop_size;
644d98a4
J
565 s->rtp_mode = avctx->rtp_mode;
566 s->rtp_payload_size = avctx->rtp_payload_size;
81401c1f
J
567 if (avctx->rtp_callback)
568 s->rtp_callback = avctx->rtp_callback;
9cdd6a24
MN
569 s->qmin= avctx->qmin;
570 s->qmax= avctx->qmax;
571 s->max_qdiff= avctx->max_qdiff;
572 s->qcompress= avctx->qcompress;
573 s->qblur= avctx->qblur;
477c35a9 574 s->avctx = avctx;
ba6802de 575 s->flags= avctx->flags;
9dbcbd92 576 s->max_b_frames= avctx->max_b_frames;
8b4c7dbc 577 s->b_frame_strategy= avctx->b_frame_strategy;
d7e9533a 578 s->codec_id= avctx->codec->id;
7f2fe444
MN
579 s->luma_elim_threshold = avctx->luma_elim_threshold;
580 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
581 s->strict_std_compliance= avctx->strict_std_compliance;
582 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
1457ab52 583 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
87f8cab4 584 s->mpeg_quant= avctx->mpeg_quant;
d7e9533a 585
de6d9b64
FB
586 if (s->gop_size <= 1) {
587 s->intra_only = 1;
588 s->gop_size = 12;
589 } else {
590 s->intra_only = 0;
591 }
5e746b99 592
1457ab52 593 s->me_method = avctx->me_method;
5e746b99 594
e4986da9 595 /* Fixed QSCALE */
de6d9b64 596 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
37fbfd0a 597
c5d309f2 598 s->adaptive_quant= ( s->avctx->lumi_masking
5e746b99 599 || s->avctx->dark_masking
c5d309f2
MN
600 || s->avctx->temporal_cplx_masking
601 || s->avctx->spatial_cplx_masking
602 || s->avctx->p_masking)
603 && !s->fixed_qscale;
fcb48651
MN
604
605 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
5e746b99 606
de6d9b64
FB
607 switch(avctx->codec->id) {
608 case CODEC_ID_MPEG1VIDEO:
609 s->out_format = FMT_MPEG1;
1ff662cc 610 avctx->delay=0; //FIXME not sure, should check the spec
de6d9b64
FB
611 break;
612 case CODEC_ID_MJPEG:
613 s->out_format = FMT_MJPEG;
614 s->intra_only = 1; /* force intra only for jpeg */
37fbfd0a 615 s->mjpeg_write_tables = 1; /* write all tables */
a69b930c 616 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
37fbfd0a
J
617 s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
618 s->mjpeg_vsample[1] = 1; /* the only currently supported values */
619 s->mjpeg_vsample[2] = 1;
a69b930c 620 s->mjpeg_hsample[0] = 2;
37fbfd0a
J
621 s->mjpeg_hsample[1] = 1;
622 s->mjpeg_hsample[2] = 1;
de6d9b64
FB
623 if (mjpeg_init(s) < 0)
624 return -1;
1ff662cc 625 avctx->delay=0;
4e00e76b 626 s->low_delay=1;
de6d9b64
FB
627 break;
628 case CODEC_ID_H263:
37fbfd0a
J
629 if (h263_get_picture_format(s->width, s->height) == 7) {
630 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
de6d9b64 631 return -1;
37fbfd0a 632 }
de6d9b64 633 s->out_format = FMT_H263;
1ff662cc 634 avctx->delay=0;
4e00e76b 635 s->low_delay=1;
de6d9b64
FB
636 break;
637 case CODEC_ID_H263P:
638 s->out_format = FMT_H263;
639 s->h263_plus = 1;
6dbd39fe 640 s->unrestricted_mv = 1;
ef5b1b5a 641 s->h263_aic = 1;
544286b3
J
642
643 /* These are just to be sure */
644 s->umvplus = 0;
645 s->umvplus_dec = 0;
1ff662cc 646 avctx->delay=0;
4e00e76b 647 s->low_delay=1;
de6d9b64
FB
648 break;
649 case CODEC_ID_RV10:
650 s->out_format = FMT_H263;
651 s->h263_rv10 = 1;
1ff662cc 652 avctx->delay=0;
4e00e76b 653 s->low_delay=1;
de6d9b64 654 break;
58f26ba9 655 case CODEC_ID_MPEG4:
de6d9b64
FB
656 s->out_format = FMT_H263;
657 s->h263_pred = 1;
658 s->unrestricted_mv = 1;
4e00e76b 659 s->low_delay= s->max_b_frames ? 0 : 1;
4d2858de 660 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 661 break;
84afee34 662 case CODEC_ID_MSMPEG4V1:
de6d9b64
FB
663 s->out_format = FMT_H263;
664 s->h263_msmpeg4 = 1;
665 s->h263_pred = 1;
666 s->unrestricted_mv = 1;
84afee34 667 s->msmpeg4_version= 1;
1ff662cc 668 avctx->delay=0;
4e00e76b 669 s->low_delay=1;
84afee34
MN
670 break;
671 case CODEC_ID_MSMPEG4V2:
672 s->out_format = FMT_H263;
673 s->h263_msmpeg4 = 1;
674 s->h263_pred = 1;
675 s->unrestricted_mv = 1;
676 s->msmpeg4_version= 2;
1ff662cc 677 avctx->delay=0;
4e00e76b 678 s->low_delay=1;
84afee34
MN
679 break;
680 case CODEC_ID_MSMPEG4V3:
681 s->out_format = FMT_H263;
682 s->h263_msmpeg4 = 1;
683 s->h263_pred = 1;
684 s->unrestricted_mv = 1;
685 s->msmpeg4_version= 3;
1ff662cc 686 avctx->delay=0;
4e00e76b 687 s->low_delay=1;
de6d9b64 688 break;
f5957f3f
MN
689 case CODEC_ID_WMV1:
690 s->out_format = FMT_H263;
691 s->h263_msmpeg4 = 1;
692 s->h263_pred = 1;
693 s->unrestricted_mv = 1;
694 s->msmpeg4_version= 4;
695 avctx->delay=0;
4e00e76b 696 s->low_delay=1;
f5957f3f
MN
697 break;
698 case CODEC_ID_WMV2:
699 s->out_format = FMT_H263;
700 s->h263_msmpeg4 = 1;
701 s->h263_pred = 1;
702 s->unrestricted_mv = 1;
703 s->msmpeg4_version= 5;
704 avctx->delay=0;
4e00e76b 705 s->low_delay=1;
f5957f3f 706 break;
de6d9b64
FB
707 default:
708 return -1;
709 }
cf8039b2 710
45870f57
MN
711 { /* set up some save defaults, some codecs might override them later */
712 static int done=0;
713 if(!done){
714 int i;
715 done=1;
bbed9259
MN
716
717 default_mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
9c15096e 718 memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
45870f57
MN
719 memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
720
721 for(i=-16; i<16; i++){
722 default_fcode_tab[i + MAX_MV]= 1;
723 }
724 }
725 }
1457ab52 726 s->me.mv_penalty= default_mv_penalty;
45870f57 727 s->fcode_tab= default_fcode_tab;
a406617f
MN
728 s->y_dc_scale_table=
729 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
730
9d2a0355 731 /* dont use mv_penalty table for crap MV as it would be confused */
1457ab52
MN
732 //FIXME remove after fixing / removing old ME
733 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
9d2a0355 734
3bb4e23a
FB
735 s->encoding = 1;
736
de6d9b64
FB
737 /* init */
738 if (MPV_common_init(s) < 0)
739 return -1;
740
1457ab52
MN
741 ff_init_me(s);
742
bbed9259 743#ifdef CONFIG_ENCODERS
2ad1516a
MN
744 if (s->out_format == FMT_H263)
745 h263_encode_init(s);
746 else if (s->out_format == FMT_MPEG1)
747 ff_mpeg1_encode_init(s);
748 if(s->msmpeg4_version)
749 ff_msmpeg4_encode_init(s);
bbed9259 750#endif
2ad1516a 751
519c2b6d
FB
752 /* init default q matrix */
753 for(i=0;i<64;i++) {
2ad1516a 754 int j= s->idct_permutation[i];
87f8cab4 755 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
2ad1516a
MN
756 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
757 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
87f8cab4 758 }else if(s->out_format == FMT_H263){
2ad1516a
MN
759 s->intra_matrix[j] =
760 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
87f8cab4 761 }else{ /* mpeg1 */
2ad1516a
MN
762 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
763 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
87f8cab4 764 }
d7e9533a
MN
765 }
766
767 /* precompute matrix */
ef5b1b5a 768 /* for mjpeg, we do include qscale in the matrix */
d7e9533a 769 if (s->out_format != FMT_MJPEG) {
28db7fce 770 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
cc7ac888 771 s->intra_matrix, s->intra_quant_bias, 1, 31);
28db7fce 772 convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
cc7ac888 773 s->inter_matrix, s->inter_quant_bias, 1, 31);
519c2b6d
FB
774 }
775
8b4c7dbc
MN
776 if(ff_rate_control_init(s) < 0)
777 return -1;
de6d9b64
FB
778
779 s->picture_number = 0;
45870f57 780 s->picture_in_gop_number = 0;
de6d9b64
FB
781 s->fake_picture_number = 0;
782 /* motion detector init */
783 s->f_code = 1;
9dbcbd92 784 s->b_code = 1;
de6d9b64
FB
785
786 return 0;
787}
788
789int MPV_encode_end(AVCodecContext *avctx)
790{
791 MpegEncContext *s = avctx->priv_data;
792
793#ifdef STATS
794 print_stats();
795#endif
8b4c7dbc
MN
796
797 ff_rate_control_uninit(s);
798
de6d9b64
FB
799 MPV_common_end(s);
800 if (s->out_format == FMT_MJPEG)
801 mjpeg_close(s);
37fbfd0a 802
de6d9b64
FB
803 return 0;
804}
805
806/* draw the edges of width 'w' of an image of size width, height */
fd7db0fd 807//FIXME check that this is ok for mpeg4 interlaced
3d9fccbf 808static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
de6d9b64
FB
809{
810 UINT8 *ptr, *last_line;
811 int i;
812
813 last_line = buf + (height - 1) * wrap;
814 for(i=0;i<w;i++) {
815 /* top and bottom */
816 memcpy(buf - (i + 1) * wrap, buf, width);
817 memcpy(last_line + (i + 1) * wrap, last_line, width);
818 }
819 /* left and right */
820 ptr = buf;
821 for(i=0;i<height;i++) {
822 memset(ptr - w, ptr[0], w);
823 memset(ptr + width, ptr[width-1], w);
824 ptr += wrap;
825 }
826 /* corners */
827 for(i=0;i<w;i++) {
828 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
829 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
830 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
831 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
832 }
833}
834
4e00e76b
MN
835static int find_unused_picture(MpegEncContext *s, int shared){
836 int i;
837
838 if(shared){
839 for(i=0; i<MAX_PICTURE_COUNT; i++){
840 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
841 }
842 }else{
843 for(i=0; i<MAX_PICTURE_COUNT; i++){
844 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break;
845 }
846 for(i=0; i<MAX_PICTURE_COUNT; i++){
847 if(s->picture[i].data[0]==NULL) break;
848 }
849 }
850
851 assert(i<MAX_PICTURE_COUNT);
852 return i;
853}
854
de6d9b64 855/* generic function for encode/decode called before a frame is coded/decoded */
d6db1c9c 856int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
de6d9b64 857{
4e00e76b 858 int i;
492cd3a9 859 AVFrame *pic;
de6d9b64 860
425dddb7 861 s->mb_skiped = 0;
1e491e29
MN
862
863 /* mark&release old frames */
864 if (s->pict_type != B_TYPE && s->last_picture.data[0]) {
1e491e29 865 for(i=0; i<MAX_PICTURE_COUNT; i++){
4e00e76b 866//printf("%8X %d %d %X %X\n", s->picture[i].data[0], s->picture[i].type, i, s->next_picture.data[0], s->last_picture.data[0]);
1e491e29
MN
867 if(s->picture[i].data[0] == s->last_picture.data[0]){
868// s->picture[i].reference=0;
492cd3a9 869 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1e491e29
MN
870 break;
871 }
872 }
873 assert(i<MAX_PICTURE_COUNT);
874
875 /* release forgotten pictures */
876 /* if(mpeg124/h263) */
877 if(!s->encoding){
878 for(i=0; i<MAX_PICTURE_COUNT; i++){
879 if(s->picture[i].data[0] && s->picture[i].data[0] != s->next_picture.data[0] && s->picture[i].reference){
880 fprintf(stderr, "releasing zombie picture\n");
492cd3a9 881 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1e491e29
MN
882 }
883 }
d6db1c9c 884 }
93a21abd 885 }
aa388dba
MN
886alloc:
887 if(!s->encoding){
4e00e76b 888 i= find_unused_picture(s, 0);
1e491e29 889
492cd3a9 890 pic= (AVFrame*)&s->picture[i];
1e491e29
MN
891 pic->reference= s->pict_type != B_TYPE;
892 pic->coded_picture_number= s->current_picture.coded_picture_number+1;
893
4e00e76b 894 alloc_picture(s, (Picture*)pic, 0);
93a21abd 895
1e491e29
MN
896 s->current_picture= s->picture[i];
897 }
b7adc711 898
1e491e29
MN
899 if (s->pict_type != B_TYPE) {
900 s->last_picture= s->next_picture;
901 s->next_picture= s->current_picture;
de6d9b64 902 }
aa388dba
MN
903
904 if(s->pict_type != I_TYPE && s->last_picture.data[0]==NULL){
905 fprintf(stderr, "warning: first frame is no keyframe\n");
906 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
907 goto alloc;
908 }
1e491e29 909
aa388dba
MN
910 s->hurry_up= s->avctx->hurry_up;
911 s->error_resilience= avctx->error_resilience;
912
d930ef19
MN
913 /* set dequantizer, we cant do it during init as it might change for mpeg4
914 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
915 if(s->out_format == FMT_H263){
916 if(s->mpeg_quant)
917 s->dct_unquantize = s->dct_unquantize_mpeg2;
918 else
919 s->dct_unquantize = s->dct_unquantize_h263;
920 }else
921 s->dct_unquantize = s->dct_unquantize_mpeg1;
d6db1c9c
MN
922
923 return 0;
de6d9b64 924}
21af69f7 925
de6d9b64
FB
926/* generic function for encode/decode called after a frame has been coded/decoded */
927void MPV_frame_end(MpegEncContext *s)
928{
1e491e29 929 int i;
de6d9b64 930 /* draw edge for correct motion prediction if outside */
1e491e29
MN
931 if(s->codec_id!=CODEC_ID_SVQ1){
932 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
933 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
934 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
935 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
936 }
de6d9b64 937 }
5975626d 938 emms_c();
8b4c7dbc 939
3aa102be 940 s->last_pict_type = s->pict_type;
8b4c7dbc
MN
941 if(s->pict_type!=B_TYPE){
942 s->last_non_b_pict_type= s->pict_type;
8b4c7dbc 943 }
1e491e29
MN
944
945 s->current_picture.quality= s->qscale; //FIXME get average of qscale_table
946 s->current_picture.pict_type= s->pict_type;
947 s->current_picture.key_frame= s->pict_type == I_TYPE;
948
949 /* copy back current_picture variables */
950 for(i=0; i<MAX_PICTURE_COUNT; i++){
951 if(s->picture[i].data[0] == s->current_picture.data[0]){
952 s->picture[i]= s->current_picture;
953 break;
954 }
955 }
956 assert(i<MAX_PICTURE_COUNT);
957
958 /* release non refernce frames */
959 for(i=0; i<MAX_PICTURE_COUNT; i++){
4e00e76b 960 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
492cd3a9 961 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1e491e29 962 }
1457ab52
MN
963 if(s->avctx->debug&FF_DEBUG_SKIP){
964 int x,y;
965 for(y=0; y<s->mb_height; y++){
966 for(x=0; x<s->mb_width; x++){
967 int count= s->mbskip_table[x + y*s->mb_width];
968 if(count>9) count=9;
969 printf(" %1d", count);
970 }
971 printf("\n");
972 }
973 printf("pict type: %d\n", s->pict_type);
974 }
de6d9b64
FB
975}
976
0d1e9246
MN
977static int get_sae(uint8_t *src, int ref, int stride){
978 int x,y;
979 int acc=0;
980
981 for(y=0; y<16; y++){
982 for(x=0; x<16; x++){
983 acc+= ABS(src[x+y*stride] - ref);
984 }
985 }
986
987 return acc;
988}
989
990static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
991 int x, y, w, h;
992 int acc=0;
993
994 w= s->width &~15;
995 h= s->height&~15;
996
997 for(y=0; y<h; y+=16){
998 for(x=0; x<w; x+=16){
999 int offset= x + y*stride;
1000 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1001 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1002 int sae = get_sae(src + offset, mean, stride);
1003
1004 acc+= sae + 500 < sad;
1005 }
1006 }
1007 return acc;
1008}
1009
4e00e76b 1010
492cd3a9
MN
1011static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1012 AVFrame *pic;
4e00e76b 1013 int i;
1e491e29 1014 const int encoding_delay= s->max_b_frames;
4e00e76b 1015 int direct=1;
1e491e29 1016
4e00e76b
MN
1017 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1018 if(pic_arg->linesize[0] != s->linesize) direct=0;
1019 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1020 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1021
1022// printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1e491e29 1023
4e00e76b
MN
1024 if(direct){
1025 i= find_unused_picture(s, 1);
1e491e29 1026
492cd3a9 1027 pic= (AVFrame*)&s->picture[i];
4e00e76b 1028 pic->reference= 1;
1e491e29 1029
4e00e76b
MN
1030 for(i=0; i<4; i++){
1031 pic->data[i]= pic_arg->data[i];
1032 pic->linesize[i]= pic_arg->linesize[i];
1033 }
1034 alloc_picture(s, (Picture*)pic, 1);
1035 }else{
1036 i= find_unused_picture(s, 0);
1e491e29 1037
492cd3a9 1038 pic= (AVFrame*)&s->picture[i];
4e00e76b 1039 pic->reference= 1;
1e491e29 1040
4e00e76b
MN
1041 alloc_picture(s, (Picture*)pic, 0);
1042
1043 if( pic->data[0] == pic_arg->data[0]
1044 && pic->data[1] == pic_arg->data[1]
1045 && pic->data[2] == pic_arg->data[2]){
1e491e29 1046 // empty
4e00e76b
MN
1047 }else{
1048 int h_chroma_shift, v_chroma_shift;
1e491e29 1049
4e00e76b 1050 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1e491e29 1051
4e00e76b
MN
1052 for(i=0; i<3; i++){
1053 int src_stride= pic_arg->linesize[i];
1054 int dst_stride= i ? s->uvlinesize : s->linesize;
1055 int h_shift= i ? h_chroma_shift : 0;
1056 int v_shift= i ? v_chroma_shift : 0;
1057 int w= s->width >>h_shift;
1058 int h= s->height>>v_shift;
1059 uint8_t *src= pic_arg->data[i];
1060 uint8_t *dst= pic->data[i];
1e491e29 1061
4e00e76b
MN
1062 if(src_stride==dst_stride)
1063 memcpy(dst, src, src_stride*h);
1064 else{
1065 while(h--){
1066 memcpy(dst, src, w);
1067 dst += dst_stride;
1068 src += src_stride;
1069 }
1e491e29 1070 }
9dbcbd92 1071 }
1e491e29
MN
1072 }
1073 }
4e00e76b
MN
1074 pic->quality= pic_arg->quality;
1075 pic->pict_type= pic_arg->pict_type;
369fe599 1076 pic->pts = pic_arg->pts;
4e00e76b
MN
1077
1078 if(s->input_picture[encoding_delay])
1079 pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1080
1081 /* shift buffer entries */
1082 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1083 s->input_picture[i-1]= s->input_picture[i];
1084
1085 s->input_picture[encoding_delay]= (Picture*)pic;
1e491e29
MN
1086
1087 return 0;
1088}
9dbcbd92 1089
1e491e29
MN
1090static void select_input_picture(MpegEncContext *s){
1091 int i;
1092 const int encoding_delay= s->max_b_frames;
1093 int coded_pic_num=0;
1094
1095 if(s->reordered_input_picture[0])
1096 coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
4e00e76b 1097
1e491e29
MN
1098 for(i=1; i<MAX_PICTURE_COUNT; i++)
1099 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1100 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1101
1102 /* set next picture types & ordering */
1103 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
0d1e9246
MN
1104 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture.data[0]==NULL || s->intra_only){
1105 s->reordered_input_picture[0]= s->input_picture[0];
1106 s->reordered_input_picture[0]->pict_type= I_TYPE;
1107 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1108 }else{
1109 int b_frames;
1110
1111 if(s->flags&CODEC_FLAG_PASS2){
1112 for(i=0; i<s->max_b_frames+1; i++){
1113 int pict_num= s->input_picture[0]->display_picture_number + i;
1114 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1115 s->input_picture[i]->pict_type= pict_type;
1116
1117 if(i + 1 >= s->rc_context.num_entries) break;
1118 }
1119 }
4e00e76b 1120
0d1e9246
MN
1121 if(s->input_picture[0]->pict_type){
1122 /* user selected pict_type */
140cb663
MN
1123 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1124 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1125 }
0d1e9246 1126
140cb663
MN
1127 if(b_frames > s->max_b_frames){
1128 fprintf(stderr, "warning, too many bframes in a row\n");
1129 b_frames = s->max_b_frames;
140cb663 1130 }
0d1e9246
MN
1131 }else if(s->b_frame_strategy==0){
1132 b_frames= s->max_b_frames;
1133 }else if(s->b_frame_strategy==1){
1134 for(i=1; i<s->max_b_frames+1; i++){
1135 if(s->input_picture[i]->b_frame_score==0){
1136 s->input_picture[i]->b_frame_score=
4e00e76b
MN
1137 get_intra_count(s, s->input_picture[i ]->data[0],
1138 s->input_picture[i-1]->data[0], s->linesize) + 1;
0d1e9246
MN
1139 }
1140 }
1141 for(i=0; i<s->max_b_frames; i++){
1142 if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1143 }
1144
1145 b_frames= FFMAX(0, i-1);
140cb663 1146
0d1e9246
MN
1147 /* reset scores */
1148 for(i=0; i<b_frames+1; i++){
1149 s->input_picture[i]->b_frame_score=0;
1150 }
1151 }else{
1152 fprintf(stderr, "illegal b frame strategy\n");
1153 b_frames=0;
140cb663 1154 }
0d1e9246
MN
1155
1156 emms_c();
1157//static int b_count=0;
1158//b_count+= b_frames;
1159//printf("b_frames: %d\n", b_count);
1160
1161 s->reordered_input_picture[0]= s->input_picture[b_frames];
1162 if( s->picture_in_gop_number + b_frames >= s->gop_size
1163 || s->reordered_input_picture[0]->pict_type== I_TYPE)
1e491e29 1164 s->reordered_input_picture[0]->pict_type= I_TYPE;
0d1e9246
MN
1165 else
1166 s->reordered_input_picture[0]->pict_type= P_TYPE;
1167 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1168 for(i=0; i<b_frames; i++){
1169 coded_pic_num++;
1170 s->reordered_input_picture[i+1]= s->input_picture[i];
1171 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1172 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
9dbcbd92
MN
1173 }
1174 }
9dbcbd92 1175 }
1e491e29
MN
1176
1177 if(s->reordered_input_picture[0]){
4e00e76b
MN
1178 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE;
1179
1180 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1181 int i= find_unused_picture(s, 0);
1182 Picture *pic= &s->picture[i];
1183
1184 s->new_picture= *s->reordered_input_picture[0];
1185
1186 /* mark us unused / free shared pic */
1187 for(i=0; i<4; i++)
1188 s->reordered_input_picture[0]->data[i]= NULL;
1189 s->reordered_input_picture[0]->type= 0;
1190
1191 pic->pict_type = s->reordered_input_picture[0]->pict_type;
1192 pic->quality = s->reordered_input_picture[0]->quality;
1193 pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1194 pic->reference = s->reordered_input_picture[0]->reference;
1195
1196 alloc_picture(s, pic, 0);
1197
1198 s->current_picture= *pic;
1199 }else{
1200 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1201 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1202
1203 s->new_picture= *s->reordered_input_picture[0];
1204
1205 for(i=0; i<4; i++){
1206 s->reordered_input_picture[0]->data[i]-=16; //FIXME dirty
1207 }
1208 s->current_picture= *s->reordered_input_picture[0];
1e491e29 1209 }
1e491e29
MN
1210
1211 s->picture_number= s->new_picture.display_picture_number;
1212//printf("dpn:%d\n", s->picture_number);
1213 }else{
1214 memset(&s->new_picture, 0, sizeof(Picture));
9dbcbd92
MN
1215 }
1216}
1217
de6d9b64
FB
1218int MPV_encode_picture(AVCodecContext *avctx,
1219 unsigned char *buf, int buf_size, void *data)
1220{
1221 MpegEncContext *s = avctx->priv_data;
492cd3a9 1222 AVFrame *pic_arg = data;
140cb663 1223 int i;
de6d9b64
FB
1224
1225 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1226
1e491e29 1227 s->picture_in_gop_number++;
de6d9b64 1228
1e491e29 1229 load_input_picture(s, pic_arg);
8b4c7dbc 1230
1e491e29 1231 select_input_picture(s);
9dbcbd92
MN
1232
1233 /* output? */
1e491e29 1234 if(s->new_picture.data[0]){
9dbcbd92 1235
1e491e29
MN
1236 s->pict_type= s->new_picture.pict_type;
1237 if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1238 s->qscale= (int)(s->new_picture.quality+0.5);
1239 assert(s->qscale);
1240 }
1241//emms_c();
1242//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
93a21abd 1243 MPV_frame_start(s, avctx);
9dbcbd92
MN
1244
1245 encode_picture(s, s->picture_number);
208d3ddf 1246
9cd3766f 1247 avctx->real_pict_num = s->picture_number;
9dbcbd92
MN
1248 avctx->header_bits = s->header_bits;
1249 avctx->mv_bits = s->mv_bits;
1250 avctx->misc_bits = s->misc_bits;
1251 avctx->i_tex_bits = s->i_tex_bits;
1252 avctx->p_tex_bits = s->p_tex_bits;
1253 avctx->i_count = s->i_count;
66370d3f 1254 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
9dbcbd92
MN
1255 avctx->skip_count = s->skip_count;
1256
1257 MPV_frame_end(s);
1258
1259 if (s->out_format == FMT_MJPEG)
1260 mjpeg_picture_trailer(s);
8b4c7dbc
MN
1261
1262 if(s->flags&CODEC_FLAG_PASS1)
1263 ff_write_pass1_stats(s);
de6d9b64
FB
1264 }
1265
9dbcbd92 1266 s->input_picture_number++;
de6d9b64
FB
1267
1268 flush_put_bits(&s->pb);
9cdd6a24 1269 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
3aa102be 1270
9cdd6a24 1271 s->total_bits += s->frame_bits;
098eefe1 1272 avctx->frame_bits = s->frame_bits;
1e491e29 1273
140cb663
MN
1274 for(i=0; i<4; i++){
1275 avctx->error[i] += s->current_picture.error[i];
1276 }
1277
17592475 1278 return pbBufPtr(&s->pb) - s->pb.buf;
de6d9b64
FB
1279}
1280
44eb4951
MN
1281static inline void gmc1_motion(MpegEncContext *s,
1282 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1283 int dest_offset,
073b013d 1284 UINT8 **ref_picture, int src_offset)
44eb4951
MN
1285{
1286 UINT8 *ptr;
0fd90455 1287 int offset, src_x, src_y, linesize, uvlinesize;
44eb4951 1288 int motion_x, motion_y;
54993774 1289 int emu=0;
44eb4951 1290
44eb4951
MN
1291 motion_x= s->sprite_offset[0][0];
1292 motion_y= s->sprite_offset[0][1];
1293 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1294 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1295 motion_x<<=(3-s->sprite_warping_accuracy);
1296 motion_y<<=(3-s->sprite_warping_accuracy);
1297 src_x = clip(src_x, -16, s->width);
1298 if (src_x == s->width)
1299 motion_x =0;
1300 src_y = clip(src_y, -16, s->height);
1301 if (src_y == s->height)
1302 motion_y =0;
073b013d 1303
44eb4951 1304 linesize = s->linesize;
0fd90455 1305 uvlinesize = s->uvlinesize;
073b013d 1306
44eb4951
MN
1307 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1308
1309 dest_y+=dest_offset;
54993774 1310 if(s->flags&CODEC_FLAG_EMU_EDGE){
741235eb
MN
1311 if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1312 || src_y + 17 >= s->v_edge_pos){
1457ab52 1313 ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
54993774 1314 ptr= s->edge_emu_buffer;
54993774
MN
1315 }
1316 }
073b013d
MN
1317
1318 if((motion_x|motion_y)&7){
eb4b3dd3
ZK
1319 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1320 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
073b013d
MN
1321 }else{
1322 int dxy;
1323
1324 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1325 if (s->no_rounding){
eb4b3dd3 1326 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
073b013d 1327 }else{
eb4b3dd3
ZK
1328 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
1329 }
073b013d
MN
1330 }
1331
1332 if(s->flags&CODEC_FLAG_GRAY) return;
44eb4951
MN
1333
1334 motion_x= s->sprite_offset[1][0];
1335 motion_y= s->sprite_offset[1][1];
1336 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1337 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1338 motion_x<<=(3-s->sprite_warping_accuracy);
1339 motion_y<<=(3-s->sprite_warping_accuracy);
1340 src_x = clip(src_x, -8, s->width>>1);
1341 if (src_x == s->width>>1)
1342 motion_x =0;
1343 src_y = clip(src_y, -8, s->height>>1);
1344 if (src_y == s->height>>1)
1345 motion_y =0;
1346
0fd90455 1347 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
44eb4951 1348 ptr = ref_picture[1] + offset;
741235eb
MN
1349 if(s->flags&CODEC_FLAG_EMU_EDGE){
1350 if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1351 || src_y + 9 >= s->v_edge_pos>>1){
1352 ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1353 ptr= s->edge_emu_buffer;
1354 emu=1;
1355 }
54993774 1356 }
eb4b3dd3 1357 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
54993774 1358
44eb4951 1359 ptr = ref_picture[2] + offset;
54993774 1360 if(emu){
1457ab52 1361 ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
54993774
MN
1362 ptr= s->edge_emu_buffer;
1363 }
eb4b3dd3 1364 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
44eb4951
MN
1365
1366 return;
1367}
1368
073b013d
MN
1369static inline void gmc_motion(MpegEncContext *s,
1370 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1371 int dest_offset,
1372 UINT8 **ref_picture, int src_offset)
1373{
1374 UINT8 *ptr;
1375 int linesize, uvlinesize;
1376 const int a= s->sprite_warping_accuracy;
1377 int ox, oy;
1378
1379 linesize = s->linesize;
1380 uvlinesize = s->uvlinesize;
1381
1382 ptr = ref_picture[0] + src_offset;
1383
1384 dest_y+=dest_offset;
1385
1386 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1387 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1388
eb4b3dd3 1389 s->dsp.gmc(dest_y, ptr, linesize, 16,
073b013d
MN
1390 ox,
1391 oy,
1392 s->sprite_delta[0][0], s->sprite_delta[0][1],
1393 s->sprite_delta[1][0], s->sprite_delta[1][1],
1394 a+1, (1<<(2*a+1)) - s->no_rounding,
1395 s->h_edge_pos, s->v_edge_pos);
eb4b3dd3 1396 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
073b013d
MN
1397 ox + s->sprite_delta[0][0]*8,
1398 oy + s->sprite_delta[1][0]*8,
1399 s->sprite_delta[0][0], s->sprite_delta[0][1],
1400 s->sprite_delta[1][0], s->sprite_delta[1][1],
1401 a+1, (1<<(2*a+1)) - s->no_rounding,
1402 s->h_edge_pos, s->v_edge_pos);
1403
1404 if(s->flags&CODEC_FLAG_GRAY) return;
1405
1406
1407 dest_cb+=dest_offset>>1;
1408 dest_cr+=dest_offset>>1;
1409
1410 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1411 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1412
1413 ptr = ref_picture[1] + (src_offset>>1);
eb4b3dd3 1414 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
073b013d
MN
1415 ox,
1416 oy,
1417 s->sprite_delta[0][0], s->sprite_delta[0][1],
1418 s->sprite_delta[1][0], s->sprite_delta[1][1],
1419 a+1, (1<<(2*a+1)) - s->no_rounding,
1420 s->h_edge_pos>>1, s->v_edge_pos>>1);
1421
1422 ptr = ref_picture[2] + (src_offset>>1);
eb4b3dd3 1423 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
073b013d
MN
1424 ox,
1425 oy,
1426 s->sprite_delta[0][0], s->sprite_delta[0][1],
1427 s->sprite_delta[1][0], s->sprite_delta[1][1],
1428 a+1, (1<<(2*a+1)) - s->no_rounding,
1429 s->h_edge_pos>>1, s->v_edge_pos>>1);
1430}
1431
1432
1457ab52 1433void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
93a21abd
MN
1434 int src_x, int src_y, int w, int h){
1435 int x, y;
1436 int start_y, start_x, end_y, end_x;
54993774 1437 UINT8 *buf= s->edge_emu_buffer;
eb4b3dd3 1438
93a21abd
MN
1439 if(src_y>= h){
1440 src+= (h-1-src_y)*linesize;
1441 src_y=h-1;
225f9c44
MN
1442 }else if(src_y<=-block_h){
1443 src+= (1-block_h-src_y)*linesize;
1444 src_y=1-block_h;
93a21abd
MN
1445 }
1446 if(src_x>= w){
1447 src+= (w-1-src_x);
1448 src_x=w-1;
225f9c44
MN
1449 }else if(src_x<=-block_w){
1450 src+= (1-block_w-src_x);
1451 src_x=1-block_w;
93a21abd
MN
1452 }
1453
b8a78f41
MN
1454 start_y= FFMAX(0, -src_y);
1455 start_x= FFMAX(0, -src_x);
1456 end_y= FFMIN(block_h, h-src_y);
1457 end_x= FFMIN(block_w, w-src_x);
54993774 1458
93a21abd
MN
1459 // copy existing part
1460 for(y=start_y; y<end_y; y++){
1461 for(x=start_x; x<end_x; x++){
1462 buf[x + y*linesize]= src[x + y*linesize];
1463 }
1464 }
1465
1466 //top
1467 for(y=0; y<start_y; y++){
1468 for(x=start_x; x<end_x; x++){
1469 buf[x + y*linesize]= buf[x + start_y*linesize];
1470 }
1471 }
1472
1473 //bottom
1474 for(y=end_y; y<block_h; y++){
1475 for(x=start_x; x<end_x; x++){
1476 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1477 }
1478 }
1479
1480 for(y=0; y<block_h; y++){
1481 //left
1482 for(x=0; x<start_x; x++){
1483 buf[x + y*linesize]= buf[start_x + y*linesize];
1484 }
1485
1486 //right
1487 for(x=end_x; x<block_w; x++){
1488 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1489 }
1490 }
1491}
1492
1493
de6d9b64
FB
1494/* apply one mpeg motion vector to the three components */
1495static inline void mpeg_motion(MpegEncContext *s,
1496 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1497 int dest_offset,
1498 UINT8 **ref_picture, int src_offset,
b3184779 1499 int field_based, op_pixels_func (*pix_op)[4],
de6d9b64
FB
1500 int motion_x, int motion_y, int h)
1501{
1502 UINT8 *ptr;
b5a093b3 1503 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
93a21abd 1504 int emu=0;
b3184779 1505#if 0
44eb4951
MN
1506if(s->quarter_sample)
1507{
1508 motion_x>>=1;
1509 motion_y>>=1;
1510}
b3184779 1511#endif
de6d9b64
FB
1512 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1513 src_x = s->mb_x * 16 + (motion_x >> 1);
1514 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1515
1516 /* WARNING: do no forget half pels */
1517 height = s->height >> field_based;
b5a093b3 1518 v_edge_pos = s->v_edge_pos >> field_based;
de6d9b64
FB
1519 src_x = clip(src_x, -16, s->width);
1520 if (src_x == s->width)
1521 dxy &= ~1;
1522 src_y = clip(src_y, -16, height);
1523 if (src_y == height)
1524 dxy &= ~2;
4c9ede2e
MN
1525 linesize = s->linesize << field_based;
1526 uvlinesize = s->uvlinesize << field_based;
de6d9b64
FB
1527 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1528 dest_y += dest_offset;
93a21abd
MN
1529
1530 if(s->flags&CODEC_FLAG_EMU_EDGE){
b5a093b3
MN
1531 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1532 || src_y + (motion_y&1) + h > v_edge_pos){
1457ab52 1533 ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
4a3d7fbc
MN
1534 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1535 ptr= s->edge_emu_buffer + src_offset;
93a21abd
MN
1536 emu=1;
1537 }
1538 }
b3184779 1539 pix_op[0][dxy](dest_y, ptr, linesize, h);
de6d9b64 1540
b50eef3a
MN
1541 if(s->flags&CODEC_FLAG_GRAY) return;
1542
de6d9b64
FB
1543 if (s->out_format == FMT_H263) {
1544 dxy = 0;
1545 if ((motion_x & 3) != 0)
1546 dxy |= 1;
1547 if ((motion_y & 3) != 0)
1548 dxy |= 2;
1549 mx = motion_x >> 2;
1550 my = motion_y >> 2;
1551 } else {
1552 mx = motion_x / 2;
1553 my = motion_y / 2;
1554 dxy = ((my & 1) << 1) | (mx & 1);
1555 mx >>= 1;
1556 my >>= 1;
1557 }
1558
1559 src_x = s->mb_x * 8 + mx;
1560 src_y = s->mb_y * (8 >> field_based) + my;
1561 src_x = clip(src_x, -8, s->width >> 1);
1562 if (src_x == (s->width >> 1))
1563 dxy &= ~1;
1564 src_y = clip(src_y, -8, height >> 1);
1565 if (src_y == (height >> 1))
1566 dxy &= ~2;
4c9ede2e 1567 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
de6d9b64 1568 ptr = ref_picture[1] + offset;
93a21abd 1569 if(emu){
1457ab52 1570 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
4a3d7fbc
MN
1571 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1572 ptr= s->edge_emu_buffer + (src_offset >> 1);
93a21abd 1573 }
b3184779 1574 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
93a21abd 1575
de6d9b64 1576 ptr = ref_picture[2] + offset;
93a21abd 1577 if(emu){
1457ab52 1578 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
4a3d7fbc
MN
1579 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1580 ptr= s->edge_emu_buffer + (src_offset >> 1);
93a21abd 1581 }
b3184779 1582 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
de6d9b64
FB
1583}
1584
44eb4951
MN
1585static inline void qpel_motion(MpegEncContext *s,
1586 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1587 int dest_offset,
1588 UINT8 **ref_picture, int src_offset,
b3184779
MN
1589 int field_based, op_pixels_func (*pix_op)[4],
1590 qpel_mc_func (*qpix_op)[16],
44eb4951
MN
1591 int motion_x, int motion_y, int h)
1592{
1593 UINT8 *ptr;
590a6358 1594 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
225f9c44 1595 int emu=0;
44eb4951
MN
1596
1597 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1598 src_x = s->mb_x * 16 + (motion_x >> 2);
1599 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1600
1601 height = s->height >> field_based;
b5a093b3 1602 v_edge_pos = s->v_edge_pos >> field_based;
44eb4951
MN
1603 src_x = clip(src_x, -16, s->width);
1604 if (src_x == s->width)
1605 dxy &= ~3;
1606 src_y = clip(src_y, -16, height);
1607 if (src_y == height)
1608 dxy &= ~12;
1609 linesize = s->linesize << field_based;
590a6358 1610 uvlinesize = s->uvlinesize << field_based;
44eb4951
MN
1611 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1612 dest_y += dest_offset;
1613//printf("%d %d %d\n", src_x, src_y, dxy);
225f9c44
MN
1614
1615 if(s->flags&CODEC_FLAG_EMU_EDGE){
b5a093b3
MN
1616 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1617 || src_y + (motion_y&3) + h > v_edge_pos){
1457ab52 1618 ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
4a3d7fbc
MN
1619 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1620 ptr= s->edge_emu_buffer + src_offset;
225f9c44
MN
1621 emu=1;
1622 }
1623 }
590a6358
MN
1624 if(!field_based)
1625 qpix_op[0][dxy](dest_y, ptr, linesize);
1626 else{
1627 //damn interlaced mode
1628 //FIXME boundary mirroring is not exactly correct here
1629 qpix_op[1][dxy](dest_y , ptr , linesize);
1630 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1631 }
b3184779 1632
b50eef3a
MN
1633 if(s->flags&CODEC_FLAG_GRAY) return;
1634
590a6358
MN
1635 if(field_based){
1636 mx= motion_x/2;
1637 my= motion_y>>1;
03e93d35 1638 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
590a6358
MN
1639 mx= (motion_x>>1)|(motion_x&1);
1640 my= (motion_y>>1)|(motion_y&1);
1641 }else{
1642 mx= motion_x/2;
1643 my= motion_y/2;
1644 }
1645 mx= (mx>>1)|(mx&1);
1646 my= (my>>1)|(my&1);
1647 dxy= (mx&1) | ((my&1)<<1);
1648 mx>>=1;
1649 my>>=1;
44eb4951 1650
44eb4951
MN
1651 src_x = s->mb_x * 8 + mx;
1652 src_y = s->mb_y * (8 >> field_based) + my;
1653 src_x = clip(src_x, -8, s->width >> 1);
1654 if (src_x == (s->width >> 1))
1655 dxy &= ~1;
1656 src_y = clip(src_y, -8, height >> 1);
1657 if (src_y == (height >> 1))
1658 dxy &= ~2;
1659
590a6358 1660 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
44eb4951 1661 ptr = ref_picture[1] + offset;
225f9c44 1662 if(emu){
1457ab52 1663 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
4a3d7fbc
MN
1664 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1665 ptr= s->edge_emu_buffer + (src_offset >> 1);
225f9c44 1666 }
590a6358 1667 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
225f9c44 1668
44eb4951 1669 ptr = ref_picture[2] + offset;
225f9c44 1670 if(emu){
1457ab52 1671 ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
4a3d7fbc
MN
1672 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1673 ptr= s->edge_emu_buffer + (src_offset >> 1);
225f9c44 1674 }
590a6358 1675 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
44eb4951
MN
1676}
1677
67725183
MN
1678inline int ff_h263_round_chroma(int x){
1679 if (x >= 0)
1680 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1681 else {
1682 x = -x;
1683 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1684 }
1685}
44eb4951 1686
de6d9b64
FB
1687static inline void MPV_motion(MpegEncContext *s,
1688 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1689 int dir, UINT8 **ref_picture,
b3184779 1690 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
de6d9b64
FB
1691{
1692 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1693 int mb_x, mb_y, i;
1694 UINT8 *ptr, *dest;
225f9c44 1695 int emu=0;
de6d9b64
FB
1696
1697 mb_x = s->mb_x;
1698 mb_y = s->mb_y;
1699
1700 switch(s->mv_type) {
1701 case MV_TYPE_16X16:
44eb4951 1702 if(s->mcsel){
073b013d
MN
1703 if(s->real_sprite_warping_points==1){
1704 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1705 ref_picture, 0);
1706 }else{
1707 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1708 ref_picture, 0);
1709 }
b3184779 1710 }else if(s->quarter_sample){
44eb4951
MN
1711 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1712 ref_picture, 0,
1713 0, pix_op, qpix_op,
1714 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1457ab52
MN
1715 }else if(s->mspel){
1716 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1717 ref_picture, pix_op,
1718 s->mv[dir][0][0], s->mv[dir][0][1], 16);
44eb4951
MN
1719 }else{
1720 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1721 ref_picture, 0,
1722 0, pix_op,
1723 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1724 }
de6d9b64
FB
1725 break;
1726 case MV_TYPE_8X8:
1e7bfebe
MN
1727 mx = 0;
1728 my = 0;
1729 if(s->quarter_sample){
1730 for(i=0;i<4;i++) {
1731 motion_x = s->mv[dir][i][0];
1732 motion_y = s->mv[dir][i][1];
1733
1734 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1735 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1736 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1737
1738 /* WARNING: do no forget half pels */
1739 src_x = clip(src_x, -16, s->width);
1740 if (src_x == s->width)
1741 dxy &= ~3;
1742 src_y = clip(src_y, -16, s->height);
1743 if (src_y == s->height)
1744 dxy &= ~12;
1745
1746 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1747 if(s->flags&CODEC_FLAG_EMU_EDGE){
1748 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1749 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1457ab52 1750 ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1e7bfebe
MN
1751 ptr= s->edge_emu_buffer;
1752 }
1753 }
1754 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1755 qpix_op[1][dxy](dest, ptr, s->linesize);
1756
1757 mx += s->mv[dir][i][0]/2;
1758 my += s->mv[dir][i][1]/2;
1759 }
1760 }else{
1761 for(i=0;i<4;i++) {
1762 motion_x = s->mv[dir][i][0];
1763 motion_y = s->mv[dir][i][1];
de6d9b64 1764
1e7bfebe
MN
1765 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1766 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1767 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
de6d9b64 1768
1e7bfebe
MN
1769 /* WARNING: do no forget half pels */
1770 src_x = clip(src_x, -16, s->width);
1771 if (src_x == s->width)
1772 dxy &= ~1;
1773 src_y = clip(src_y, -16, s->height);
1774 if (src_y == s->height)
1775 dxy &= ~2;
de6d9b64 1776
1e7bfebe
MN
1777 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1778 if(s->flags&CODEC_FLAG_EMU_EDGE){
1779 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1780 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1457ab52 1781 ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1e7bfebe
MN
1782 ptr= s->edge_emu_buffer;
1783 }
225f9c44 1784 }
1e7bfebe
MN
1785 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1786 pix_op[1][dxy](dest, ptr, s->linesize, 8);
1787
1788 mx += s->mv[dir][i][0];
1789 my += s->mv[dir][i][1];
225f9c44 1790 }
de6d9b64 1791 }
1e7bfebe 1792
b50eef3a 1793 if(s->flags&CODEC_FLAG_GRAY) break;
de6d9b64
FB
1794 /* In case of 8X8, we construct a single chroma motion vector
1795 with a special rounding */
67725183
MN
1796 mx= ff_h263_round_chroma(mx);
1797 my= ff_h263_round_chroma(my);
de6d9b64
FB
1798 dxy = ((my & 1) << 1) | (mx & 1);
1799 mx >>= 1;
1800 my >>= 1;
1801
1802 src_x = mb_x * 8 + mx;
1803 src_y = mb_y * 8 + my;
1804 src_x = clip(src_x, -8, s->width/2);
1805 if (src_x == s->width/2)
1806 dxy &= ~1;
1807 src_y = clip(src_y, -8, s->height/2);
1808 if (src_y == s->height/2)
1809 dxy &= ~2;
1810
0fd90455 1811 offset = (src_y * (s->uvlinesize)) + src_x;
de6d9b64 1812 ptr = ref_picture[1] + offset;
225f9c44 1813 if(s->flags&CODEC_FLAG_EMU_EDGE){
b5a093b3
MN
1814 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1815 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1457ab52 1816 ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
225f9c44
MN
1817 ptr= s->edge_emu_buffer;
1818 emu=1;
1819 }
1820 }
b3184779 1821 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
225f9c44 1822
de6d9b64 1823 ptr = ref_picture[2] + offset;
225f9c44 1824 if(emu){
1457ab52 1825 ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
225f9c44
MN
1826 ptr= s->edge_emu_buffer;
1827 }
b3184779 1828 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
de6d9b64
FB
1829 break;
1830 case MV_TYPE_FIELD:
1831 if (s->picture_structure == PICT_FRAME) {
590a6358
MN
1832 if(s->quarter_sample){
1833 /* top field */
1834 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1835 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1836 1, pix_op, qpix_op,
1837 s->mv[dir][0][0], s->mv[dir][0][1], 8);
1838 /* bottom field */
1839 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1840 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1841 1, pix_op, qpix_op,
1842 s->mv[dir][1][0], s->mv[dir][1][1], 8);
1843 }else{
1844 /* top field */
1845 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1846 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1847 1, pix_op,
1848 s->mv[dir][0][0], s->mv[dir][0][1], 8);
1849 /* bottom field */
1850 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1851 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1852 1, pix_op,
1853 s->mv[dir][1][0], s->mv[dir][1][1], 8);
1854 }
de6d9b64
FB
1855 } else {
1856
1857
1858 }
1859 break;
1860 }
1861}
1862
1863
1864/* put block[] to dest[] */
1865static inline void put_dct(MpegEncContext *s,
1866 DCTELEM *block, int i, UINT8 *dest, int line_size)
1867{
a0201736 1868 s->dct_unquantize(s, block, i, s->qscale);
2ad1516a 1869 s->idct_put (dest, line_size, block);
de6d9b64
FB
1870}
1871
1872/* add block[] to dest[] */
1873static inline void add_dct(MpegEncContext *s,
1874 DCTELEM *block, int i, UINT8 *dest, int line_size)
1875{
0f440e02 1876 if (s->block_last_index[i] >= 0) {
2ad1516a 1877 s->idct_add (dest, line_size, block);
0f440e02
MN
1878 }
1879}
2417652e 1880
0f440e02
MN
1881static inline void add_dequant_dct(MpegEncContext *s,
1882 DCTELEM *block, int i, UINT8 *dest, int line_size)
1883{
de6d9b64 1884 if (s->block_last_index[i] >= 0) {
0f440e02 1885 s->dct_unquantize(s, block, i, s->qscale);
9dbcbd92 1886
2ad1516a 1887 s->idct_add (dest, line_size, block);
de6d9b64
FB
1888 }
1889}
1890
7f2fe444
MN
1891/**
1892 * cleans dc, ac, coded_block for the current non intra MB
1893 */
1894void ff_clean_intra_table_entries(MpegEncContext *s)
1895{
1896 int wrap = s->block_wrap[0];
1897 int xy = s->block_index[0];
1898
1899 s->dc_val[0][xy ] =
1900 s->dc_val[0][xy + 1 ] =
1901 s->dc_val[0][xy + wrap] =
1902 s->dc_val[0][xy + 1 + wrap] = 1024;
1903 /* ac pred */
1904 memset(s->ac_val[0][xy ], 0, 32 * sizeof(INT16));
1905 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1906 if (s->msmpeg4_version>=3) {
1907 s->coded_block[xy ] =
1908 s->coded_block[xy + 1 ] =
1909 s->coded_block[xy + wrap] =
1910 s->coded_block[xy + 1 + wrap] = 0;
1911 }
1912 /* chroma */
1913 wrap = s->block_wrap[4];
1914 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1915 s->dc_val[1][xy] =
1916 s->dc_val[2][xy] = 1024;
1917 /* ac pred */
1918 memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1919 memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1920
1921 s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1922}
1923
de6d9b64
FB
1924/* generic function called after a macroblock has been parsed by the
1925 decoder or after it has been encoded by the encoder.
1926
1927 Important variables used:
1928 s->mb_intra : true if intra macroblock
1929 s->mv_dir : motion vector direction
1930 s->mv_type : motion vector type
1931 s->mv : motion vector
1932 s->interlaced_dct : true if interlaced dct used (mpeg2)
1933 */
1934void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1935{
8257bf05 1936 int mb_x, mb_y;
0f440e02 1937 const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
de6d9b64
FB
1938
1939 mb_x = s->mb_x;
1940 mb_y = s->mb_y;
1941
1e491e29 1942 s->current_picture.qscale_table[mb_xy]= s->qscale;
79e7b305 1943
de6d9b64
FB
1944 /* update DC predictors for P macroblocks */
1945 if (!s->mb_intra) {
9e15ad28 1946 if (s->h263_pred || s->h263_aic) {
0f440e02 1947 if(s->mbintra_table[mb_xy])
7f2fe444 1948 ff_clean_intra_table_entries(s);
de6d9b64 1949 } else {
7f2fe444
MN
1950 s->last_dc[0] =
1951 s->last_dc[1] =
de6d9b64
FB
1952 s->last_dc[2] = 128 << s->intra_dc_precision;
1953 }
1954 }
9e15ad28 1955 else if (s->h263_pred || s->h263_aic)
0f440e02 1956 s->mbintra_table[mb_xy]=1;
bff6ecaa 1957
c5b1c10a 1958 /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
0f440e02 1959 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1457ab52 1960 //FIXME a lot of thet is only needed for !low_delay
0f440e02
MN
1961 const int wrap = s->block_wrap[0];
1962 const int xy = s->block_index[0];
bea669e5 1963 const int mb_index= s->mb_x + s->mb_y*s->mb_width;
fd7db0fd 1964 if(s->mv_type == MV_TYPE_8X8){
bea669e5 1965 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
fd7db0fd
MN
1966 } else {
1967 int motion_x, motion_y;
1968 if (s->mb_intra) {
1969 motion_x = 0;
1970 motion_y = 0;
bea669e5
MN
1971 if(s->co_located_type_table)
1972 s->co_located_type_table[mb_index]= 0;
fd7db0fd
MN
1973 } else if (s->mv_type == MV_TYPE_16X16) {
1974 motion_x = s->mv[0][0][0];
1975 motion_y = s->mv[0][0][1];
bea669e5
MN
1976 if(s->co_located_type_table)
1977 s->co_located_type_table[mb_index]= 0;
fd7db0fd 1978 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
bea669e5 1979 int i;
fd7db0fd
MN
1980 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1981 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1982 motion_x = (motion_x>>1) | (motion_x&1);
bea669e5
MN
1983 for(i=0; i<2; i++){
1984 s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1985 s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1986 s->field_select_table[mb_index][i]= s->field_select[0][i];
1987 }
1988 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
fd7db0fd 1989 }
de6d9b64 1990 /* no update if 8X8 because it has been done during parsing */
8257bf05
ZK
1991 s->motion_val[xy][0] = motion_x;
1992 s->motion_val[xy][1] = motion_y;
1993 s->motion_val[xy + 1][0] = motion_x;
1994 s->motion_val[xy + 1][1] = motion_y;
1995 s->motion_val[xy + wrap][0] = motion_x;
1996 s->motion_val[xy + wrap][1] = motion_y;
1997 s->motion_val[xy + 1 + wrap][0] = motion_x;
1998 s->motion_val[xy + 1 + wrap][1] = motion_y;
de6d9b64
FB
1999 }
2000 }
2001
140cb663 2002 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
de6d9b64 2003 UINT8 *dest_y, *dest_cb, *dest_cr;
0f440e02 2004 int dct_linesize, dct_offset;
b3184779
MN
2005 op_pixels_func (*op_pix)[4];
2006 qpel_mc_func (*op_qpix)[16];
3bb4e23a 2007
1e491e29 2008 /* avoid copy if macroblock skipped in last frame too */
9dbcbd92 2009 if (s->pict_type != B_TYPE) {
1e491e29
MN
2010 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2011 }
2012
2013 /* skip only during decoding as we might trash the buffers during encoding a bit */
2014 if(!s->encoding){
0f440e02 2015 UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1e491e29 2016 const int age= s->current_picture.age;
0fd90455 2017
1e491e29
MN
2018 assert(age);
2019
2020 if (s->mb_skiped) {
2021 s->mb_skiped= 0;
2022 assert(s->pict_type!=I_TYPE);
2023
0fd90455
MN
2024 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2025 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2026
1e491e29 2027 /* if previous was skipped too, then nothing to do ! */
f943e138
MN
2028 if (*mbskip_ptr >= age && s->current_picture.reference){
2029 return;
1e491e29 2030 }
f943e138
MN
2031 } else if(!s->current_picture.reference){
2032 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2033 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2034 } else{
3bb4e23a
FB
2035 *mbskip_ptr = 0; /* not skipped */
2036 }
1e491e29
MN
2037 }else
2038 s->mb_skiped= 0;
de6d9b64 2039
3994623d 2040 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
1e491e29
MN
2041 dest_y = s->current_picture.data[0] + mb_x * 16;
2042 dest_cb = s->current_picture.data[1] + mb_x * 8;
2043 dest_cr = s->current_picture.data[2] + mb_x * 8;
3994623d 2044 }else{
1e491e29
MN
2045 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
2046 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2047 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3994623d 2048 }
de6d9b64
FB
2049
2050 if (s->interlaced_dct) {
2051 dct_linesize = s->linesize * 2;
2052 dct_offset = s->linesize;
2053 } else {
2054 dct_linesize = s->linesize;
2055 dct_offset = s->linesize * 8;
2056 }
2057
2058 if (!s->mb_intra) {
2059 /* motion handling */
7f2fe444 2060 /* decoding or more than one mb_type (MC was allready done otherwise) */
0f440e02 2061 if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
91029be7 2062 if ((!s->no_rounding) || s->pict_type==B_TYPE){
eb4b3dd3
ZK
2063 op_pix = s->dsp.put_pixels_tab;
2064 op_qpix= s->dsp.put_qpel_pixels_tab;
9dbcbd92 2065 }else{
eb4b3dd3
ZK
2066 op_pix = s->dsp.put_no_rnd_pixels_tab;
2067 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
9dbcbd92 2068 }
de6d9b64 2069
9dbcbd92 2070 if (s->mv_dir & MV_DIR_FORWARD) {
1e491e29 2071 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
eb4b3dd3
ZK
2072 op_pix = s->dsp.avg_pixels_tab;
2073 op_qpix= s->dsp.avg_qpel_pixels_tab;
9dbcbd92
MN
2074 }
2075 if (s->mv_dir & MV_DIR_BACKWARD) {
1e491e29 2076 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
9dbcbd92 2077 }
de6d9b64
FB
2078 }
2079
0f440e02 2080 /* skip dequant / idct if we are really late ;) */
6bb925f4 2081 if(s->hurry_up>1) return;
0f440e02 2082
de6d9b64 2083 /* add dct residue */
a0201736
MN
2084 if(s->encoding || !( s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO
2085 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
0f440e02
MN
2086 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2087 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2088 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2089 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2090
b50eef3a 2091 if(!(s->flags&CODEC_FLAG_GRAY)){
0fd90455
MN
2092 add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2093 add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
b50eef3a 2094 }
1457ab52 2095 } else if(s->codec_id != CODEC_ID_WMV2){
0f440e02
MN
2096 add_dct(s, block[0], 0, dest_y, dct_linesize);
2097 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2098 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2099 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
de6d9b64 2100
b50eef3a 2101 if(!(s->flags&CODEC_FLAG_GRAY)){
0fd90455
MN
2102 add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2103 add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
b50eef3a 2104 }
1457ab52
MN
2105 } else{
2106 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
0f440e02 2107 }
de6d9b64
FB
2108 } else {
2109 /* dct only in intra block */
a0201736
MN
2110 if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2111 put_dct(s, block[0], 0, dest_y, dct_linesize);
2112 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2113 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2114 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2115
2116 if(!(s->flags&CODEC_FLAG_GRAY)){
2117 put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2118 put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2119 }
2120 }else{
2121 s->idct_put(dest_y , dct_linesize, block[0]);
2122 s->idct_put(dest_y + 8, dct_linesize, block[1]);
2123 s->idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2124 s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2125
2126 if(!(s->flags&CODEC_FLAG_GRAY)){
2127 s->idct_put(dest_cb, s->uvlinesize, block[4]);
2128 s->idct_put(dest_cr, s->uvlinesize, block[5]);
2129 }
b50eef3a 2130 }
de6d9b64
FB
2131 }
2132 }
2133}
2134
c9178d86 2135static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
7f2fe444
MN
2136{
2137 static const char tab[64]=
2138 {3,2,2,1,1,1,1,1,
2139 1,1,1,1,1,1,1,1,
2140 1,1,1,1,1,1,1,1,
2141 0,0,0,0,0,0,0,0,
2142 0,0,0,0,0,0,0,0,
2143 0,0,0,0,0,0,0,0,
2144 0,0,0,0,0,0,0,0,
2145 0,0,0,0,0,0,0,0};
2146 int score=0;
2147 int run=0;
2148 int i;
2149 DCTELEM *block= s->block[n];
2150 const int last_index= s->block_last_index[n];
c9178d86 2151 int skip_dc;
7f2fe444 2152
f5866a03
MN
2153 if(threshold<0){
2154 skip_dc=0;
2155 threshold= -threshold;
c9178d86
MN
2156 }else
2157 skip_dc=1;
f5866a03 2158
7f2fe444
MN
2159 /* are all which we could set to zero are allready zero? */
2160 if(last_index<=skip_dc - 1) return;
2161
2162 for(i=0; i<=last_index; i++){
2ad1516a 2163 const int j = s->intra_scantable.permutated[i];
7f2fe444
MN
2164 const int level = ABS(block[j]);
2165 if(level==1){
2166 if(skip_dc && i==0) continue;
2167 score+= tab[run];
2168 run=0;
2169 }else if(level>1){
2170 return;
2171 }else{
2172 run++;
2173 }
2174 }
2175 if(score >= threshold) return;
2176 for(i=skip_dc; i<=last_index; i++){
2ad1516a 2177 const int j = s->intra_scantable.permutated[i];
7f2fe444
MN
2178 block[j]=0;
2179 }
2180 if(block[0]) s->block_last_index[n]= 0;
2181 else s->block_last_index[n]= -1;
2182}
2183
d7e9533a
MN
2184static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2185{
2186 int i;
2187 const int maxlevel= s->max_qcoeff;
2188 const int minlevel= s->min_qcoeff;
2ad1516a
MN
2189
2190 if(s->mb_intra){
2191 i=1; //skip clipping of intra dc
2192 }else
2193 i=0;
2194
2195 for(;i<=last_index; i++){
2196 const int j= s->intra_scantable.permutated[i];
d7e9533a
MN
2197 int level = block[j];
2198
2199 if (level>maxlevel) level=maxlevel;
2200 else if(level<minlevel) level=minlevel;
2201 block[j]= level;
2202 }
2203}
9dbcbd92 2204
fcb48651
MN
2205static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
2206{
2207 int i;
2ad1516a
MN
2208
2209 if(s->mb_intra){
2210 i=1; //skip clipping of intra dc
2211 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
fcb48651
MN
2212 }else
2213 i=0;
2214
2215 for(;i<=s->block_last_index[n]; i++){
2ad1516a 2216 const int j = s->intra_scantable.permutated[i];
fcb48651
MN
2217 int level = block[j];
2218
2219 block[j]= ROUNDED_DIV(level*oldq, newq);
2220 }
2221
2222 for(i=s->block_last_index[n]; i>=0; i--){
2ad1516a 2223 const int j = s->intra_scantable.permutated[i];
fcb48651
MN
2224 if(block[j]) break;
2225 }
2226 s->block_last_index[n]= i;
2227}
2228
2229static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
2230{
2231 int i,n, newq;
2232 const int maxlevel= s->max_qcoeff;
2233 const int minlevel= s->min_qcoeff;
2234 int largest=0, smallest=0;
2235
2236 assert(s->adaptive_quant);
2237
2238 for(n=0; n<6; n++){
2ad1516a
MN
2239 if(s->mb_intra){
2240 i=1; //skip clipping of intra dc
2241 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2242 }else
2243 i=0;
fcb48651
MN
2244
2245 for(;i<=s->block_last_index[n]; i++){
2ad1516a 2246 const int j = s->intra_scantable.permutated[i];
fcb48651
MN
2247 int level = block[n][j];
2248 if(largest < level) largest = level;
2249 if(smallest > level) smallest= level;
2250 }
2251 }
2252
2253 for(newq=s->qscale+1; newq<32; newq++){
2254 if( ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
2255 && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel)
2256 break;
2257 }
2258
2259 if(s->out_format==FMT_H263){
2260 /* h263 like formats cannot change qscale by more than 2 easiely */
2261 if(s->avctx->qmin + 2 < newq)
2262 newq= s->avctx->qmin + 2;
2263 }
2264
2265 for(n=0; n<6; n++){
2266 requantize_coeffs(s, block[n], s->qscale, newq, n);
2267 clip_coeffs(s, block[n], s->block_last_index[n]);
2268 }
2269
2270 s->dquant+= newq - s->qscale;
2271 s->qscale= newq;
2272}
2273#if 0
2274static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2275 int score=0;
2276 int x,y;
2277
2278 for(y=0; y<7; y++){
2279 for(x=0; x<16; x+=4){
2280 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
2281 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2282 }
2283 s+= stride;
2284 }
2285
2286 return score;
2287}
2288
2289static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2290 int score=0;
2291 int x,y;
2292
2293 for(y=0; y<7; y++){
2294 for(x=0; x<16; x++){
2295 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2296 }
2297 s1+= stride;
2298 s2+= stride;
2299 }
2300
2301 return score;
2302}
2303#else
2304#define SQ(a) ((a)*(a))
2305
2306static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2307 int score=0;
2308 int x,y;
2309
2310 for(y=0; y<7; y++){
2311 for(x=0; x<16; x+=4){
2312 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
2313 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2314 }
2315 s+= stride;
2316 }
2317
2318 return score;
2319}
2320
2321static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2322 int score=0;
2323 int x,y;
2324
2325 for(y=0; y<7; y++){
2326 for(x=0; x<16; x++){
2327 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2328 }
2329 s1+= stride;
2330 s2+= stride;
2331 }
2332
2333 return score;
2334}
2335
2336#endif
4d2858de
MN
2337
2338void ff_draw_horiz_band(MpegEncContext *s){
2339 if ( s->avctx->draw_horiz_band
4e00e76b 2340 && (s->last_picture.data[0] || s->low_delay) ) {
4d2858de
MN
2341 UINT8 *src_ptr[3];
2342 int y, h, offset;
2343 y = s->mb_y * 16;
2344 h = s->height - y;
2345 if (h > 16)
2346 h = 16;
2347
2348 if(s->pict_type==B_TYPE)
2349 offset = 0;
2350 else
2351 offset = y * s->linesize;
2352
4e00e76b 2353 if(s->pict_type==B_TYPE || s->low_delay){
1e491e29
MN
2354 src_ptr[0] = s->current_picture.data[0] + offset;
2355 src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2356 src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
4d2858de 2357 } else {
1e491e29
MN
2358 src_ptr[0] = s->last_picture.data[0] + offset;
2359 src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2360 src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
4d2858de 2361 }
0aa7875a
MN
2362 emms_c();
2363
4d2858de
MN
2364 s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2365 y, s->width, h);
2366 }
2367}
2368
9dbcbd92 2369static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
de6d9b64 2370{
ba6802de
MN
2371 const int mb_x= s->mb_x;
2372 const int mb_y= s->mb_y;
ba6802de 2373 int i;
7f2fe444 2374 int skip_dct[6];
fcb48651
MN
2375 int dct_offset = s->linesize*8; //default for progressive frames
2376
7f2fe444 2377 for(i=0; i<6; i++) skip_dct[i]=0;
c5d309f2
MN
2378
2379 if(s->adaptive_quant){
1e491e29 2380 s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
fcb48651
MN
2381
2382 if(s->out_format==FMT_H263){
c5d309f2
MN
2383 if (s->dquant> 2) s->dquant= 2;
2384 else if(s->dquant<-2) s->dquant=-2;
fcb48651
MN
2385 }
2386
2387 if(s->codec_id==CODEC_ID_MPEG4){
c5d309f2
MN
2388 if(!s->mb_intra){
2389 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2390
2391 if(s->mv_dir&MV_DIRECT)
2392 s->dquant=0;
2393 }
2394 }
2395 s->qscale+= s->dquant;
2396 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2397 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2398 }
ba6802de 2399
9dbcbd92
MN
2400 if (s->mb_intra) {
2401 UINT8 *ptr;
fcb48651 2402 int wrap_y;
79c0c785 2403 int emu=0;
9dbcbd92 2404
fcb48651 2405 wrap_y = s->linesize;
1e491e29 2406 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
fcb48651 2407
79c0c785 2408 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
1457ab52 2409 ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
79c0c785
MN
2410 ptr= s->edge_emu_buffer;
2411 emu=1;
2412 }
fcb48651
MN
2413
2414 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2415 int progressive_score, interlaced_score;
2416
2417 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2418 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
2419
2420 if(progressive_score > interlaced_score + 100){
2421 s->interlaced_dct=1;
2422
2423 dct_offset= wrap_y;
2424 wrap_y<<=1;
2425 }else
2426 s->interlaced_dct=0;
2427 }
2428
eb4b3dd3
ZK
2429 s->dsp.get_pixels(s->block[0], ptr , wrap_y);
2430 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y);
2431 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y);
2432 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
9dbcbd92 2433
6282185e
MN
2434 if(s->flags&CODEC_FLAG_GRAY){
2435 skip_dct[4]= 1;
2436 skip_dct[5]= 1;
2437 }else{
fcb48651 2438 int wrap_c = s->uvlinesize;
1e491e29 2439 ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
79c0c785 2440 if(emu){
1457ab52 2441 ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
79c0c785
MN
2442 ptr= s->edge_emu_buffer;
2443 }
eb4b3dd3 2444 s->dsp.get_pixels(s->block[4], ptr, wrap_c);
9dbcbd92 2445
1e491e29 2446 ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
79c0c785 2447 if(emu){
1457ab52 2448 ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
79c0c785
MN
2449 ptr= s->edge_emu_buffer;
2450 }
eb4b3dd3 2451 s->dsp.get_pixels(s->block[5], ptr, wrap_c);
6282185e 2452 }
9dbcbd92 2453 }else{
b3184779
MN
2454 op_pixels_func (*op_pix)[4];
2455 qpel_mc_func (*op_qpix)[16];
9dbcbd92 2456 UINT8 *dest_y, *dest_cb, *dest_cr;
7f2fe444
MN
2457 UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2458 int wrap_y, wrap_c;
79c0c785 2459 int emu=0;
9dbcbd92 2460
1e491e29
MN
2461 dest_y = s->current_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
2462 dest_cb = s->current_picture.data[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2463 dest_cr = s->current_picture.data[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
7f2fe444 2464 wrap_y = s->linesize;
fcb48651 2465 wrap_c = s->uvlinesize;
1e491e29
MN
2466 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2467 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2468 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
9dbcbd92 2469
91029be7 2470 if ((!s->no_rounding) || s->pict_type==B_TYPE){
eb4b3dd3
ZK
2471 op_pix = s->dsp.put_pixels_tab;
2472 op_qpix= s->dsp.put_qpel_pixels_tab;
cf8039b2 2473 }else{
eb4b3dd3
ZK
2474 op_pix = s->dsp.put_no_rnd_pixels_tab;
2475 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
9dbcbd92
MN
2476 }
2477
2478 if (s->mv_dir & MV_DIR_FORWARD) {
1e491e29 2479 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
eb4b3dd3
ZK
2480 op_pix = s->dsp.avg_pixels_tab;
2481 op_qpix= s->dsp.avg_qpel_pixels_tab;
9dbcbd92
MN
2482 }
2483 if (s->mv_dir & MV_DIR_BACKWARD) {
1e491e29 2484 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
ba6802de 2485 }
9dbcbd92 2486
79c0c785 2487 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
1457ab52 2488 ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
79c0c785
MN
2489 ptr_y= s->edge_emu_buffer;
2490 emu=1;
2491 }
fcb48651
MN
2492
2493 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2494 int progressive_score, interlaced_score;
2495
2496 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
2497 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
2498 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
2499 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
2500
2501 if(progressive_score > interlaced_score + 600){
2502 s->interlaced_dct=1;
2503
2504 dct_offset= wrap_y;
2505 wrap_y<<=1;
2506 }else
2507 s->interlaced_dct=0;
2508 }
2509
eb4b3dd3
ZK
2510 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
2511 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2512 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
2513 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
6282185e
MN
2514
2515 if(s->flags&CODEC_FLAG_GRAY){
2516 skip_dct[4]= 1;
2517 skip_dct[5]= 1;
2518 }else{
79c0c785 2519 if(emu){
1457ab52 2520 ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
79c0c785
MN
2521 ptr_cb= s->edge_emu_buffer;
2522 }
eb4b3dd3 2523 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
79c0c785 2524 if(emu){
1457ab52 2525 ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
79c0c785
MN
2526 ptr_cr= s->edge_emu_buffer;
2527 }
eb4b3dd3 2528 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
6282185e 2529 }
7f2fe444 2530 /* pre quantization */
1e491e29 2531 if(s->current_picture.mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
fcb48651 2532 //FIXME optimize
eb4b3dd3
ZK
2533 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2534 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2535 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2536 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2571e3b6
MN
2537 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2538 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
7f2fe444
MN
2539#if 0
2540{
2541 static int stat[7];
2542 int num=0;
2543 for(i=0; i<6; i++)
2544 if(skip_dct[i]) num++;
2545 stat[num]++;
2546
2547 if(s->mb_x==0 && s->mb_y==0){
2548 for(i=0; i<7; i++){
2549 printf("%6d %1d\n", stat[i], i);
2550 }
2551 }
2552}
2553#endif
2554 }
9dbcbd92 2555
ba6802de
MN
2556 }
2557
2558#if 0
2559 {
2560 float adap_parm;
2561
2562 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2563 ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2564
2565 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2566 (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
2567 s->qscale, adap_parm, s->qscale*adap_parm,
2568 s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2569 }
2570#endif
2571 /* DCT & quantize */
d7e9533a
MN
2572 if(s->out_format==FMT_MJPEG){
2573 for(i=0;i<6;i++) {
2574 int overflow;
28db7fce 2575 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
ef5b1b5a 2576 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
d7e9533a
MN
2577 }
2578 }else{
2579 for(i=0;i<6;i++) {
7f2fe444
MN
2580 if(!skip_dct[i]){
2581 int overflow;
28db7fce 2582 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
d7e9533a 2583 // FIXME we could decide to change to quantizer instead of clipping
ef5b1b5a
J
2584 // JS: I don't think that would be a good idea it could lower quality instead
2585 // of improve it. Just INTRADC clipping deserves changes in quantizer
7f2fe444
MN
2586 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2587 }else
2588 s->block_last_index[i]= -1;
d7e9533a 2589 }
7f2fe444
MN
2590 if(s->luma_elim_threshold && !s->mb_intra)
2591 for(i=0; i<4; i++)
c9178d86 2592 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
7f2fe444
MN
2593 if(s->chroma_elim_threshold && !s->mb_intra)
2594 for(i=4; i<6; i++)
c9178d86 2595 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
ba6802de
MN
2596 }
2597
6282185e
MN
2598 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2599 s->block_last_index[4]=
2600 s->block_last_index[5]= 0;
2601 s->block[4][0]=
1d0eab1d 2602 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
6282185e
MN
2603 }
2604
bbed9259 2605#ifdef CONFIG_ENCODERS
ba6802de 2606 /* huffman encode */
1457ab52
MN
2607 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2608 case CODEC_ID_MPEG1VIDEO:
2609 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2610 case CODEC_ID_MPEG4:
2611 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2612 case CODEC_ID_MSMPEG4V2:
2613 case CODEC_ID_MSMPEG4V3:
2614 case CODEC_ID_WMV1:
2615 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2616 case CODEC_ID_WMV2:
2617 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2618 case CODEC_ID_MJPEG:
2619 mjpeg_encode_mb(s, s->block); break;
2620 case CODEC_ID_H263:
2621 case CODEC_ID_H263P:
2622 case CODEC_ID_RV10:
2623 h263_encode_mb(s, s->block, motion_x, motion_y); break;
2624 default:
2625 assert(0);
ba6802de 2626 }
bbed9259 2627#endif
ba6802de
MN
2628}
2629
b7a22d84
MN
2630/**
2631 * combines the (truncated) bitstream to a complete frame
2632 * @returns -1 if no complete frame could be created
2633 */
2634int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2635 ParseContext *pc= &s->parse_context;
2636
2637 pc->last_index= pc->index;
2638
2639 if(next==-1){
2640 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2641
2642 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2643 pc->index += *buf_size;
2644 return -1;
2645 }
2646
2647 if(pc->index){
2648 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2649
2650 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2651 pc->index = 0;
2652 *buf= pc->buffer;
2653 *buf_size= pc->last_index + next;
2654 }
2655
2656 return 0;
2657}
2658
7f2fe444 2659void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
ba6802de 2660{
1f0cd30f
MN
2661 int bytes= length>>4;
2662 int bits= length&15;
2663 int i;
2664
7f2fe444
MN
2665 if(length==0) return;
2666
1f0cd30f
MN
2667 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2668 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
ba6802de
MN
2669}
2670
7f2fe444 2671static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
1f0cd30f
MN
2672 int i;
2673
2674 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2675
2676 /* mpeg1 */
2677 d->mb_incr= s->mb_incr;
2678 for(i=0; i<3; i++)
2679 d->last_dc[i]= s->last_dc[i];
2680
2681 /* statistics */
2682 d->mv_bits= s->mv_bits;
2683 d->i_tex_bits= s->i_tex_bits;
2684 d->p_tex_bits= s->p_tex_bits;
2685 d->i_count= s->i_count;
66370d3f
MN
2686 d->f_count= s->f_count;
2687 d->b_count= s->b_count;
1f0cd30f
MN
2688 d->skip_count= s->skip_count;
2689 d->misc_bits= s->misc_bits;
8b4c7dbc 2690 d->last_bits= 0;
91029be7
MN
2691
2692 d->mb_skiped= s->mb_skiped;
5f3ed165 2693 d->qscale= s->qscale;
1f0cd30f
MN
2694}
2695
7f2fe444 2696static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
1f0cd30f
MN
2697 int i;
2698
2699 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2700 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2701
2702 /* mpeg1 */
2703 d->mb_incr= s->mb_incr;
2704 for(i=0; i<3; i++)
2705 d->last_dc[i]= s->last_dc[i];
2706
2707 /* statistics */
2708 d->mv_bits= s->mv_bits;
2709 d->i_tex_bits= s->i_tex_bits;
2710 d->p_tex_bits= s->p_tex_bits;
2711 d->i_count= s->i_count;
66370d3f
MN
2712 d->f_count= s->f_count;
2713 d->b_count= s->b_count;
1f0cd30f
MN
2714 d->skip_count= s->skip_count;
2715 d->misc_bits= s->misc_bits;
1f0cd30f
MN
2716
2717 d->mb_intra= s->mb_intra;
91029be7 2718 d->mb_skiped= s->mb_skiped;
1f0cd30f
MN
2719 d->mv_type= s->mv_type;
2720 d->mv_dir= s->mv_dir;
2721 d->pb= s->pb;
7f2fe444
MN
2722 if(s->data_partitioning){
2723 d->pb2= s->pb2;
2724 d->tex_pb= s->tex_pb;
2725 }
1f0cd30f
MN
2726 d->block= s->block;
2727 for(i=0; i<6; i++)
2728 d->block_last_index[i]= s->block_last_index[i];
fb8a9e2f 2729 d->interlaced_dct= s->interlaced_dct;
5f3ed165 2730 d->qscale= s->qscale;
1f0cd30f
MN
2731}
2732
7f2fe444
MN
2733static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2734 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2735 int *dmin, int *next_block, int motion_x, int motion_y)
2736{
2737 int bits_count;
2738
2739 copy_context_before_encode(s, backup, type);
2740
2741 s->block= s->blocks[*next_block];
2742 s->pb= pb[*next_block];
2743 if(s->data_partitioning){
2744 s->pb2 = pb2 [*next_block];
2745 s->tex_pb= tex_pb[*next_block];
2746 }
2747
2748 encode_mb(s, motion_x, motion_y);
2749
2750 bits_count= get_bit_count(&s->pb);
2751 if(s->data_partitioning){
2752 bits_count+= get_bit_count(&s->pb2);
2753 bits_count+= get_bit_count(&s->tex_pb);
2754 }
2755
2756 if(bits_count<*dmin){
2757 *dmin= bits_count;
2758 *next_block^=1;
2759
2760 copy_context_after_encode(best, s, type);
2761 }
2762}
140cb663
MN
2763
2764static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2765 uint32_t *sq = squareTbl + 256;
2766 int acc=0;
2767 int x,y;
2768
2769 if(w==16 && h==16)
1457ab52
MN
2770 return s->dsp.sse[0](NULL, src1, src2, stride);
2771 else if(w==8 && h==8)
2772 return s->dsp.sse[1](NULL, src1, src2, stride);
140cb663
MN
2773
2774 for(y=0; y<h; y++){
2775 for(x=0; x<w; x++){
2776 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2777 }
2778 }
1457ab52
MN
2779
2780 assert(acc>=0);
2781
140cb663
MN
2782 return acc;
2783}
1f0cd30f 2784
ba6802de
MN
2785static void encode_picture(MpegEncContext *s, int picture_number)
2786{
945eeee1 2787 int mb_x, mb_y, pdif = 0;
ba6802de 2788 int i;
098eefe1 2789 int bits;
1f0cd30f 2790 MpegEncContext best_s, backup_s;
7f2fe444
MN
2791 UINT8 bit_buf[2][3000];
2792 UINT8 bit_buf2[2][3000];
2793 UINT8 bit_buf_tex[2][3000];
2794 PutBitContext pb[2], pb2[2], tex_pb[2];
2795
2796 for(i=0; i<2; i++){
2797 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
2798 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
2799 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2800 }
de6d9b64
FB
2801
2802 s->picture_number = picture_number;
9cdd6a24 2803
ba6802de
MN
2804 s->block_wrap[0]=
2805 s->block_wrap[1]=
2806 s->block_wrap[2]=
2807 s->block_wrap[3]= s->mb_width*2 + 2;
2808 s->block_wrap[4]=
2809 s->block_wrap[5]= s->mb_width + 2;
2810
9cdd6a24 2811 /* Reset the average MB variance */
1e491e29
MN
2812 s->current_picture.mb_var_sum = 0;
2813 s->current_picture.mc_mb_var_sum = 0;
91029be7
MN
2814
2815 /* we need to initialize some time vars before we can encode b-frames */
2816 if (s->h263_pred && !s->h263_msmpeg4)
2817 ff_set_mpeg4_time(s, s->picture_number);
2818
1fb4890b 2819 s->scene_change_score=0;
c5d309f2
MN
2820
2821 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
1457ab52
MN
2822
2823 if(s->msmpeg4_version){
2824 if(s->pict_type==I_TYPE)
2825 s->no_rounding=1;
2826 else if(s->flipflop_rounding)
2827 s->no_rounding ^= 1;
c442d75c 2828 }else if(s->out_format == FMT_H263){
1457ab52
MN
2829 if(s->pict_type==I_TYPE)
2830 s->no_rounding=0;
2831 else if(s->pict_type!=B_TYPE)
2832 s->no_rounding ^= 1;
2833 }
9cdd6a24 2834 /* Estimate motion for every MB */
67725183 2835 s->mb_intra=0; //for the rate distoration & bit compare functions
9dbcbd92 2836 if(s->pict_type != I_TYPE){
f5fb6b34
MN
2837 if(s->pict_type != B_TYPE){
2838 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
f931ff7b 2839 s->me.pre_pass=1;
826f429a 2840 s->me.dia_size= s->avctx->pre_dia_size;
f931ff7b 2841
f5fb6b34
MN
2842 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2843 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2844 s->mb_x = mb_x;
2845 s->mb_y = mb_y;
2846 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2847 }
2848 }
f931ff7b 2849 s->me.pre_pass=0;
f5fb6b34
MN
2850 }
2851 }
2852
826f429a 2853 s->me.dia_size= s->avctx->dia_size;
ba6802de
MN
2854 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2855 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2856 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2857 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2858 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2859 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2860 s->mb_x = mb_x;
2861 s->mb_y = mb_y;
2862 s->block_index[0]+=2;
2863 s->block_index[1]+=2;
2864 s->block_index[2]+=2;
2865 s->block_index[3]+=2;
826f429a 2866
ba6802de 2867 /* compute motion vector & mb_type and store in context */
9dbcbd92
MN
2868 if(s->pict_type==B_TYPE)
2869 ff_estimate_b_frame_motion(s, mb_x, mb_y);
2870 else
2871 ff_estimate_p_frame_motion(s, mb_x, mb_y);
9cdd6a24 2872 }
9cdd6a24 2873 }
7f2fe444 2874 }else /* if(s->pict_type == I_TYPE) */{
ba6802de
MN
2875 /* I-Frame */
2876 //FIXME do we need to zero them?
2877 memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
9dbcbd92 2878 memset(s->p_mv_table , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
ba6802de 2879 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
3aa102be
MN
2880
2881 if(!s->fixed_qscale){
2882 /* finding spatial complexity for I-frame rate control */
2883 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2884 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2885 int xx = mb_x * 16;
2886 int yy = mb_y * 16;
1e491e29 2887 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3aa102be 2888 int varc;
eb4b3dd3 2889 int sum = s->dsp.pix_sum(pix, s->linesize);
3aa102be 2890
eb4b3dd3 2891 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3aa102be 2892
1e491e29
MN
2893 s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2894 s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2895 s->current_picture.mb_var_sum += varc;
3aa102be
MN
2896 }
2897 }
2898 }
9cdd6a24 2899 }
6bb925f4
MN
2900 emms_c();
2901
1fb4890b 2902 if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
bd31a775 2903 s->pict_type= I_TYPE;
ba6802de 2904 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
1e491e29 2905//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
bd31a775 2906 }
1e491e29 2907
9dbcbd92
MN
2908 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE)
2909 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2910 ff_fix_long_p_mvs(s);
2911 if(s->pict_type==B_TYPE){
2912 s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2913 s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
91029be7
MN
2914
2915 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2916 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2917 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2918 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
45870f57 2919 }
9dbcbd92 2920
c5d309f2 2921 if (s->fixed_qscale)
1e491e29 2922 s->frame_qscale = s->current_picture.quality;
c5d309f2
MN
2923 else
2924 s->frame_qscale = ff_rate_estimate_qscale(s);
8b4c7dbc 2925
9e4c6948
MN
2926 if(s->adaptive_quant){
2927 switch(s->codec_id){
2928 case CODEC_ID_MPEG4:
2929 ff_clean_mpeg4_qscales(s);
2930 break;
2931 case CODEC_ID_H263:
2932 case CODEC_ID_H263P:
2933 ff_clean_h263_qscales(s);
2934 break;
2935 }
2936
1e491e29 2937 s->qscale= s->current_picture.qscale_table[0];
9e4c6948 2938 }else
c5d309f2
MN
2939 s->qscale= (int)(s->frame_qscale + 0.5);
2940
de6d9b64
FB
2941 if (s->out_format == FMT_MJPEG) {
2942 /* for mjpeg, we do include qscale in the matrix */
adc09b2e 2943 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2ad1516a
MN
2944 for(i=1;i<64;i++){
2945 int j= s->idct_permutation[i];
2946
2947 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2948 }
28db7fce 2949 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
cc7ac888 2950 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
de6d9b64 2951 }
1e491e29
MN
2952
2953 //FIXME var duplication
2954 s->current_picture.key_frame= s->pict_type == I_TYPE;
2955 s->current_picture.pict_type= s->pict_type;
2956
2957 if(s->current_picture.key_frame)
2958 s->picture_in_gop_number=0;
de6d9b64 2959
098eefe1 2960 s->last_bits= get_bit_count(&s->pb);
de6d9b64
FB
2961 switch(s->out_format) {
2962 case FMT_MJPEG:
2963 mjpeg_picture_header(s);
2964 break;
2965 case FMT_H263:
1457ab52
MN
2966 if (s->codec_id == CODEC_ID_WMV2)
2967 ff_wmv2_encode_picture_header(s, picture_number);
2968 else if (s->h263_msmpeg4)
de6d9b64
FB
2969 msmpeg4_encode_picture_header(s, picture_number);
2970 else if (s->h263_pred)
2971 mpeg4_encode_picture_header(s, picture_number);
2972 else if (s->h263_rv10)
2973 rv10_encode_picture_header(s, picture_number);
2974 else
2975 h263_encode_picture_header(s, picture_number);
2976 break;
2977 case FMT_MPEG1:
2978 mpeg1_encode_picture_header(s, picture_number);
2979 break;
2980 }
098eefe1
MN
2981 bits= get_bit_count(&s->pb);
2982 s->header_bits= bits - s->last_bits;
2983 s->last_bits= bits;
2984 s->mv_bits=0;
2985 s->misc_bits=0;
2986 s->i_tex_bits=0;
2987 s->p_tex_bits=0;
2988 s->i_count=0;
66370d3f
MN
2989 s->f_count=0;
2990 s->b_count=0;
098eefe1
MN
2991 s->skip_count=0;
2992
140cb663
MN
2993 for(i=0; i<3; i++){
2994 /* init last dc values */
2995 /* note: quant matrix value (8) is implied here */
2996 s->last_dc[i] = 128;
2997
2998 s->current_picture.error[i] = 0;
2999 }
de6d9b64
FB
3000 s->mb_incr = 1;
3001 s->last_mv[0][0][0] = 0;
3002 s->last_mv[0][0][1] = 0;
de6d9b64 3003
945eeee1 3004 if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
4d2858de 3005 s->gob_index = ff_h263_get_gob_height(s);
7f2fe444 3006
4d2858de 3007 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
7f2fe444
MN
3008 ff_mpeg4_init_partitions(s);
3009
3010 s->resync_mb_x=0;
3011 s->resync_mb_y=0;
4d2858de 3012 s->first_slice_line = 1;
945eeee1
MN
3013 s->ptr_lastgob = s->pb.buf;
3014 s->ptr_last_mb_line = s->pb.buf;
e03c341e 3015 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
f5957f3f
MN
3016 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3017 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
e03c341e 3018
4278e7a6
MN
3019 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3020 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3021 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3022 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3023 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
3024 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
37fbfd0a 3025 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
67725183 3026 int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
91029be7 3027 const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
7f2fe444 3028// int d;
ba6802de 3029 int dmin=10000000;
37fbfd0a
J
3030
3031 s->mb_x = mb_x;
3032 s->mb_y = mb_y;
4278e7a6
MN
3033 s->block_index[0]+=2;
3034 s->block_index[1]+=2;
3035 s->block_index[2]+=2;
3036 s->block_index[3]+=2;
3037 s->block_index[4]++;
3038 s->block_index[5]++;
945eeee1
MN
3039
3040 /* write gob / video packet header */
3041 if(s->rtp_mode){
3042 int current_packet_size, is_gob_start;
3043
3044 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3045 is_gob_start=0;
3046
3047 if(s->codec_id==CODEC_ID_MPEG4){
3048 if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
3049 && s->mb_y + s->mb_x>0){
3050
4d2858de 3051 if(s->partitioned_frame){
7f2fe444
MN
3052 ff_mpeg4_merge_partitions(s);
3053 ff_mpeg4_init_partitions(s);
3054 }
3055 ff_mpeg4_encode_video_packet_header(s);
3056
3057 if(s->flags&CODEC_FLAG_PASS1){
3058 int bits= get_bit_count(&s->pb);
3059 s->misc_bits+= bits - s->last_bits;
3060 s->last_bits= bits;
3061 }
3062 ff_mpeg4_clean_buffers(s);
945eeee1 3063 is_gob_start=1;
7f2fe444 3064 }
945eeee1
MN
3065 }else{
3066 if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
3067 && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3068
3069 h263_encode_gob_header(s, mb_y);
3070 is_gob_start=1;
3071 }
3072 }
3073
3074 if(is_gob_start){
7f2fe444
MN
3075 s->ptr_lastgob = pbBufPtr(&s->pb);
3076 s->first_slice_line=1;
3077 s->resync_mb_x=mb_x;
3078 s->resync_mb_y=mb_y;
3079 }
4d2858de 3080 }
7f2fe444 3081
4d2858de
MN
3082 if( (s->resync_mb_x == s->mb_x)
3083 && s->resync_mb_y+1 == s->mb_y){
3084 s->first_slice_line=0;
7f2fe444
MN
3085 }
3086
ba6802de 3087 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
91029be7 3088 int next_block=0;
7f2fe444 3089 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
1f0cd30f
MN
3090
3091 copy_context_before_encode(&backup_s, s, -1);
7f2fe444
MN
3092 backup_s.pb= s->pb;
3093 best_s.data_partitioning= s->data_partitioning;
4d2858de 3094 best_s.partitioned_frame= s->partitioned_frame;
7f2fe444
MN
3095 if(s->data_partitioning){
3096 backup_s.pb2= s->pb2;
3097 backup_s.tex_pb= s->tex_pb;
3098 }
1f0cd30f 3099
ba6802de 3100 if(mb_type&MB_TYPE_INTER){
91029be7 3101 s->mv_dir = MV_DIR_FORWARD;
cf8039b2 3102 s->mv_type = MV_TYPE_16X16;
ba6802de 3103 s->mb_intra= 0;
9dbcbd92
MN
3104 s->mv[0][0][0] = s->p_mv_table[xy][0];
3105 s->mv[0][0][1] = s->p_mv_table[xy][1];
7f2fe444
MN
3106 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
3107 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
de6d9b64 3108 }
1f0cd30f 3109 if(mb_type&MB_TYPE_INTER4V){
91029be7 3110 s->mv_dir = MV_DIR_FORWARD;
cf8039b2
MN
3111 s->mv_type = MV_TYPE_8X8;
3112 s->mb_intra= 0;
3113 for(i=0; i<4; i++){
3114 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3115 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3116 }
7f2fe444
MN
3117 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
3118 &dmin, &next_block, 0, 0);
91029be7
MN
3119 }
3120 if(mb_type&MB_TYPE_FORWARD){
91029be7
MN
3121 s->mv_dir = MV_DIR_FORWARD;
3122 s->mv_type = MV_TYPE_16X16;
3123 s->mb_intra= 0;
3124 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3125 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
7f2fe444
MN
3126 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
3127 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
91029be7
MN
3128 }
3129 if(mb_type&MB_TYPE_BACKWARD){
91029be7
MN
3130 s->mv_dir = MV_DIR_BACKWARD;
3131 s->mv_type = MV_TYPE_16X16;
3132 s->mb_intra= 0;
3133 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3134 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
7f2fe444
MN
3135 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3136 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
91029be7
MN
3137 }
3138 if(mb_type&MB_TYPE_BIDIR){
91029be7
MN
3139 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3140 s->mv_type = MV_TYPE_16X16;
3141 s->mb_intra= 0;
3142 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3143 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3144 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3145 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
7f2fe444
MN
3146 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
3147 &dmin, &next_block, 0, 0);
91029be7
MN
3148 }
3149 if(mb_type&MB_TYPE_DIRECT){
1457ab52
MN
3150 int mx= s->b_direct_mv_table[xy][0];
3151 int my= s->b_direct_mv_table[xy][1];
3152
91029be7 3153 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
91029be7 3154 s->mb_intra= 0;
1457ab52 3155 ff_mpeg4_set_direct_mv(s, mx, my);
7f2fe444 3156 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
1457ab52 3157 &dmin, &next_block, mx, my);
cf8039b2 3158 }
ba6802de 3159 if(mb_type&MB_TYPE_INTRA){
91029be7 3160 s->mv_dir = MV_DIR_FORWARD;
cf8039b2 3161 s->mv_type = MV_TYPE_16X16;
ba6802de
MN
3162 s->mb_intra= 1;
3163 s->mv[0][0][0] = 0;
3164 s->mv[0][0][1] = 0;
7f2fe444
MN
3165 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3166 &dmin, &next_block, 0, 0);
1f0cd30f
MN
3167 /* force cleaning of ac/dc pred stuff if needed ... */
3168 if(s->h263_pred || s->h263_aic)
3169 s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
cf8039b2 3170 }
1f0cd30f 3171 copy_context_after_encode(s, &best_s, -1);
7f2fe444
MN
3172
3173 pb_bits_count= get_bit_count(&s->pb);
3174 flush_put_bits(&s->pb);
3175 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3176 s->pb= backup_s.pb;
3177
3178 if(s->data_partitioning){
3179 pb2_bits_count= get_bit_count(&s->pb2);
3180 flush_put_bits(&s->pb2);
3181 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3182 s->pb2= backup_s.pb2;
3183
3184 tex_pb_bits_count= get_bit_count(&s->tex_pb);
3185 flush_put_bits(&s->tex_pb);
3186 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3187 s->tex_pb= backup_s.tex_pb;
3188 }
8b4c7dbc 3189 s->last_bits= get_bit_count(&s->pb);
de6d9b64 3190 } else {
9dbcbd92 3191 int motion_x, motion_y;
67725183
MN
3192 int intra_score;
3193 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_width];
3194
3195 if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3196 /* get luma score */
3197 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3198 intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_width]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3199 }else{
3200 uint8_t *dest_y;
3201
3202 int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_width]; //FIXME
3203 mean*= 0x01010101;
3204
3205 dest_y = s->new_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
3206
3207 for(i=0; i<16; i++){
3208 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3209 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3210 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3211 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3212 }
3213
3214 s->mb_intra=1;
3215 intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3216
3217/* printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
3218 s->current_picture.mb_var[mb_x + mb_y*s->mb_width],
3219 s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_width]);*/
3220 }
3221
3222 /* get chroma score */
3223 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3224 int i;
3225
3226 s->mb_intra=1;
3227 for(i=1; i<3; i++){
3228 uint8_t *dest_c;
3229 int mean;
3230
3231 if(s->out_format == FMT_H263){
3232 mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3233 }else{
3234 mean= (s->last_dc[i] + 4)>>3;
3235 }
3236 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3237
3238 mean*= 0x01010101;
3239 for(i=0; i<8; i++){
3240 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3241 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3242 }
3243
3244 intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3245 }
3246 }
3247
3248 /* bias */
3249 switch(s->avctx->mb_cmp&0xFF){
3250 default:
3251 case FF_CMP_SAD:
3252 intra_score+= 32*s->qscale;
3253 break;
3254 case FF_CMP_SSE:
3255 intra_score+= 24*s->qscale*s->qscale;
3256 break;
3257 case FF_CMP_SATD:
3258 intra_score+= 96*s->qscale;
3259 break;
3260 case FF_CMP_DCT:
3261 intra_score+= 48*s->qscale;
3262 break;
3263 case FF_CMP_BIT:
3264 intra_score+= 16;
3265 break;
3266 case FF_CMP_PSNR:
3267 case FF_CMP_RD:
3268 intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3269 break;
3270 }
3271
3272 if(intra_score < inter_score)
3273 mb_type= MB_TYPE_INTRA;