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