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