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