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