minor optimization
[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.
8f2ab833 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
de6d9b64 5 *
ff4ec49e
FB
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
de6d9b64 10 *
ff4ec49e 11 * This library is distributed in the hope that it will be useful,
de6d9b64 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
de6d9b64 15 *
ff4ec49e
FB
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
cf8039b2 19 *
9dbf1ddd 20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
de6d9b64 21 */
202ef8b8 22
983e3246
MN
23/**
24 * @file mpegvideo.c
25 * The simplest mpeg encoder (well, it was the simplest!).
26 */
27
de6d9b64
FB
28#include "avcodec.h"
29#include "dsputil.h"
30#include "mpegvideo.h"
65e4c8c9 31#include "faandct.h"
e96682e6 32#include <limits.h>
de6d9b64 33
54329dd5
NK
34#ifdef USE_FASTMEMCPY
35#include "fastmemcpy.h"
36#endif
37
e4eadb4b
MN
38//#undef NDEBUG
39//#include <assert.h>
2ad1516a 40
7604246d 41#ifdef CONFIG_ENCODERS
21af69f7 42static void encode_picture(MpegEncContext *s, int picture_number);
7604246d 43#endif //CONFIG_ENCODERS
d50635cd 44static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
21af69f7 45 DCTELEM *block, int n, int qscale);
d50635cd 46static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
9dbf1ddd 47 DCTELEM *block, int n, int qscale);
d50635cd
MN
48static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54static void dct_unquantize_h263_inter_c(MpegEncContext *s,
21af69f7 55 DCTELEM *block, int n, int qscale);
c6148de2
MN
56static void dct_unquantize_h261_intra_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58static void dct_unquantize_h261_inter_c(MpegEncContext *s,
59 DCTELEM *block, int n, int qscale);
0c1a9eda 60static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
7604246d 61#ifdef CONFIG_ENCODERS
d7e9533a 62static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
477ab036 63static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
77ea0d4b 64static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
7d1c3fc1 65static int sse_mb(MpegEncContext *s);
783df5f3 66static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
7604246d 67#endif //CONFIG_ENCODERS
3d9fccbf 68
2e7b4c84
IK
69#ifdef HAVE_XVMC
70extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
71extern void XVMC_field_end(MpegEncContext *s);
a579db0c 72extern void XVMC_decode_mb(MpegEncContext *s);
2e7b4c84
IK
73#endif
74
0c1a9eda 75void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
3d9fccbf 76
de6d9b64
FB
77
78/* enable all paranoid tests for rounding, overflows, etc... */
79//#define PARANOID
80
81//#define DEBUG
82
101bea5f 83
de6d9b64
FB
84/* for jpeg fast DCT */
85#define CONST_BITS 14
86
eb4b3dd3 87static const uint16_t aanscales[64] = {
de6d9b64
FB
88 /* precomputed values scaled up by 14 bits */
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
1457ab52
MN
95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
de6d9b64
FB
97};
98
eb4b3dd3 99static const uint8_t h263_chroma_roundtab[16] = {
67725183 100// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
de6d9b64
FB
101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
102};
103
332f9ac4
MN
104static const uint8_t ff_default_chroma_qscale_table[32]={
105// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
106 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
107};
108
7604246d 109#ifdef CONFIG_ENCODERS
30952237 110static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
0c1a9eda 111static uint8_t default_fcode_tab[MAX_MV*2+1];
45870f57 112
a33c7159
MN
113enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
114
6b56c616 115static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
0c1a9eda 116 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
de6d9b64 117{
d7e9533a
MN
118 int qscale;
119
cc7ac888 120 for(qscale=qmin; qscale<=qmax; qscale++){
d7e9533a 121 int i;
6b56c616 122 if (dsp->fdct == ff_jpeg_fdct_islow
b4c3816c 123#ifdef FAAN_POSTSCALE
6b56c616 124 || dsp->fdct == ff_faandct
b4c3816c
MN
125#endif
126 ) {
28db7fce 127 for(i=0;i<64;i++) {
6b56c616 128 const int j= dsp->idct_permutation[i];
28db7fce
MN
129 /* 16 <= qscale * quant_matrix[i] <= 7905 */
130 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
131 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
132 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
133
0c1a9eda 134 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
28db7fce
MN
135 (qscale * quant_matrix[j]));
136 }
6b56c616 137 } else if (dsp->fdct == fdct_ifast
b4c3816c 138#ifndef FAAN_POSTSCALE
6b56c616 139 || dsp->fdct == ff_faandct
b4c3816c
MN
140#endif
141 ) {
d7e9533a 142 for(i=0;i<64;i++) {
6b56c616 143 const int j= dsp->idct_permutation[i];
d7e9533a
MN
144 /* 16 <= qscale * quant_matrix[i] <= 7905 */
145 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
146 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
147 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
148
0c1a9eda 149 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
d7e9533a
MN
150 (aanscales[i] * qscale * quant_matrix[j]));
151 }
152 } else {
153 for(i=0;i<64;i++) {
6b56c616 154 const int j= dsp->idct_permutation[i];
d7e9533a
MN
155 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
156 So 16 <= qscale * quant_matrix[i] <= 7905
157 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
158 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
159 */
0c1a9eda 160 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
477ab036 161// qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
642ccefb 162 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
d7e9533a 163
642ccefb
MN
164 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
165 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
d7e9533a 166 }
de6d9b64
FB
167 }
168 }
169}
158c7f05
MN
170
171static inline void update_qscale(MpegEncContext *s){
172 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
173 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
174
175 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
176}
7604246d
WH
177#endif //CONFIG_ENCODERS
178
3d2e8cce 179void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
2ad1516a
MN
180 int i;
181 int end;
7801d21d
MN
182
183 st->scantable= src_scantable;
2ad1516a
MN
184
185 for(i=0; i<64; i++){
186 int j;
187 j = src_scantable[i];
3d2e8cce 188 st->permutated[i] = permutation[j];
05c4072b
MN
189#ifdef ARCH_POWERPC
190 st->inverse[j] = i;
191#endif
2ad1516a
MN
192 }
193
194 end=-1;
195 for(i=0; i<64; i++){
196 int j;
197 j = st->permutated[i];
198 if(j>end) end=j;
199 st->raster_end[i]= end;
200 }
201}
202
764ef400 203#ifdef CONFIG_ENCODERS
d6eb3c50
MN
204void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
205 int i;
206
207 if(matrix){
208 put_bits(pb, 1, 1);
209 for(i=0;i<64;i++) {
210 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
211 }
212 }else
213 put_bits(pb, 1, 0);
214}
764ef400 215#endif //CONFIG_ENCODERS
d6eb3c50 216
defdfc9a
AB
217/* init common dct for both encoder and decoder */
218int DCT_common_init(MpegEncContext *s)
de6d9b64 219{
d50635cd
MN
220 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
221 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
c6148de2
MN
222 s->dct_unquantize_h261_intra = dct_unquantize_h261_intra_c;
223 s->dct_unquantize_h261_inter = dct_unquantize_h261_inter_c;
d50635cd
MN
224 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
225 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
226 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
227 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
b0368839 228
7604246d 229#ifdef CONFIG_ENCODERS
28db7fce 230 s->dct_quantize= dct_quantize_c;
783df5f3 231 s->denoise_dct= denoise_dct_c;
b0368839 232#endif
21af69f7
FB
233
234#ifdef HAVE_MMX
e4eadb4b 235 MPV_common_init_mmx(s);
a9b3f630 236#endif
e0580f8c
FH
237#ifdef ARCH_ALPHA
238 MPV_common_init_axp(s);
239#endif
c7e07931
MO
240#ifdef HAVE_MLIB
241 MPV_common_init_mlib(s);
242#endif
5917d17c
LS
243#ifdef HAVE_MMI
244 MPV_common_init_mmi(s);
245#endif
676e200c 246#ifdef ARCH_ARMV4L
83f238cb 247 MPV_common_init_armv4l(s);
676e200c 248#endif
05c4072b
MN
249#ifdef ARCH_POWERPC
250 MPV_common_init_ppc(s);
251#endif
676e200c 252
7604246d 253#ifdef CONFIG_ENCODERS
3a87ac94
MN
254 s->fast_dct_quantize= s->dct_quantize;
255
477ab036
MN
256 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
257 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
258 }
259
7604246d
WH
260#endif //CONFIG_ENCODERS
261
2ad1516a
MN
262 /* load & permutate scantables
263 note: only wmv uses differnt ones
264 */
bb198e19
MN
265 if(s->alternate_scan){
266 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
267 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
268 }else{
269 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
270 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
271 }
3d2e8cce
MN
272 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
273 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
d930ef19 274
defdfc9a
AB
275 return 0;
276}
277
6571e41d
MN
278static void copy_picture(Picture *dst, Picture *src){
279 *dst = *src;
280 dst->type= FF_BUFFER_TYPE_COPY;
281}
282
137c8468
MN
283static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
284 int i;
285
71c47d6e
MN
286 dst->pict_type = src->pict_type;
287 dst->quality = src->quality;
288 dst->coded_picture_number = src->coded_picture_number;
289 dst->display_picture_number = src->display_picture_number;
290// dst->reference = src->reference;
291 dst->pts = src->pts;
292 dst->interlaced_frame = src->interlaced_frame;
293 dst->top_field_first = src->top_field_first;
137c8468 294
a4d36c11
MN
295 if(s->avctx->me_threshold){
296 if(!src->motion_val[0])
297 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
298 if(!src->mb_type)
299 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
300 if(!src->ref_index[0])
301 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
137c8468 302 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
f4f3223f
MN
303 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
304 src->motion_subsample_log2, dst->motion_subsample_log2);
a4d36c11
MN
305
306 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
307
308 for(i=0; i<2; i++){
137c8468
MN
309 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
310 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
311
a4d36c11
MN
312 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
313 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
314 }
315 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
7c4f71c4 316 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
a4d36c11 317 }
137c8468
MN
318 }
319 }
71c47d6e
MN
320}
321
1e491e29 322/**
4e00e76b
MN
323 * allocates a Picture
324 * The pixels are allocated/set by calling get_buffer() if shared=0
1e491e29 325 */
4e00e76b 326static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
7bc9090a
MN
327 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
328 const int mb_array_size= s->mb_stride*s->mb_height;
b40cd4e0
MN
329 const int b8_array_size= s->b8_stride*s->mb_height*2;
330 const int b4_array_size= s->b4_stride*s->mb_height*4;
0da71265 331 int i;
7bc9090a 332
4e00e76b
MN
333 if(shared){
334 assert(pic->data[0]);
335 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
336 pic->type= FF_BUFFER_TYPE_SHARED;
337 }else{
338 int r;
339
340 assert(!pic->data[0]);
341
492cd3a9 342 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
4e00e76b
MN
343
344 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
9b879566 345 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
4e00e76b
MN
346 return -1;
347 }
348
349 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
9b879566 350 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
4e00e76b
MN
351 return -1;
352 }
353
354 if(pic->linesize[1] != pic->linesize[2]){
9b879566 355 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
4e00e76b
MN
356 return -1;
357 }
358
359 s->linesize = pic->linesize[0];
360 s->uvlinesize= pic->linesize[1];
1e491e29 361 }
4e00e76b
MN
362
363 if(pic->qscale_table==NULL){
364 if (s->encoding) {
7bc9090a
MN
365 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
366 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
367 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
4e00e76b 368 }
1e491e29 369
7bc9090a 370 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
e4eadb4b 371 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
507a8e0d 372 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
7bc9090a 373 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
0da71265 374 if(s->out_format == FMT_H264){
0da71265 375 for(i=0; i<2; i++){
37923cd3
MN
376 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2) * sizeof(int16_t))
377 pic->motion_val[i]= pic->motion_val_base[i]+2;
7c4f71c4 378 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
b40cd4e0 379 }
5ea4b18d 380 pic->motion_subsample_log2= 2;
0c9bbaec 381 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
b40cd4e0 382 for(i=0; i<2; i++){
137c8468 383 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
37923cd3 384 pic->motion_val[i]= pic->motion_val_base[i]+2;
7c4f71c4 385 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
0da71265 386 }
5ea4b18d 387 pic->motion_subsample_log2= 3;
0da71265 388 }
8289c6fa
WH
389 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
390 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
391 }
7bc9090a 392 pic->qstride= s->mb_stride;
fa384dcc 393 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
4e00e76b 394 }
0da71265 395
f943e138
MN
396 //it might be nicer if the application would keep track of these but it would require a API change
397 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
398 s->prev_pict_types[0]= s->pict_type;
399 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
400 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
401
1e491e29
MN
402 return 0;
403fail: //for the CHECKED_ALLOCZ macro
404 return -1;
405}
406
4e00e76b
MN
407/**
408 * deallocates a picture
409 */
1e491e29
MN
410static void free_picture(MpegEncContext *s, Picture *pic){
411 int i;
4e00e76b
MN
412
413 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
492cd3a9 414 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
4e00e76b
MN
415 }
416
1e491e29
MN
417 av_freep(&pic->mb_var);
418 av_freep(&pic->mc_mb_var);
419 av_freep(&pic->mb_mean);
420 av_freep(&pic->mbskip_table);
421 av_freep(&pic->qscale_table);
0da71265 422 av_freep(&pic->mb_type_base);
8289c6fa 423 av_freep(&pic->dct_coeff);
fa384dcc 424 av_freep(&pic->pan_scan);
0da71265
MN
425 pic->mb_type= NULL;
426 for(i=0; i<2; i++){
b40cd4e0 427 av_freep(&pic->motion_val_base[i]);
0da71265
MN
428 av_freep(&pic->ref_index[i]);
429 }
d90cf87b
MN
430
431 if(pic->type == FF_BUFFER_TYPE_SHARED){
4e00e76b
MN
432 for(i=0; i<4; i++){
433 pic->base[i]=
434 pic->data[i]= NULL;
435 }
436 pic->type= 0;
1e491e29
MN
437 }
438}
439
9c3d33d6
MN
440static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
441 int i;
442
259630df 443 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
9c3d33d6
MN
444 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
445 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
446
447 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
ffdff4d7 448 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
9c3d33d6
MN
449 s->rd_scratchpad= s->me.scratchpad;
450 s->b_scratchpad= s->me.scratchpad;
451 s->obmc_scratchpad= s->me.scratchpad + 16;
452 if (s->encoding) {
453 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
454 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
455 if(s->avctx->noise_reduction){
456 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
457 }
458 }
5e5c247a 459 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
9c3d33d6
MN
460 s->block= s->blocks[0];
461
462 for(i=0;i<12;i++){
463 s->pblocks[i] = (short *)(&s->block[i]);
464 }
465 return 0;
466fail:
467 return -1; //free() through MPV_common_end()
468}
469
470static void free_duplicate_context(MpegEncContext *s){
471 if(s==NULL) return;
472
473 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
474 av_freep(&s->me.scratchpad);
475 s->rd_scratchpad=
476 s->b_scratchpad=
477 s->obmc_scratchpad= NULL;
478
479 av_freep(&s->dct_error_sum);
480 av_freep(&s->me.map);
481 av_freep(&s->me.score_map);
482 av_freep(&s->blocks);
483 s->block= NULL;
484}
485
486static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
487#define COPY(a) bak->a= src->a
488 COPY(allocated_edge_emu_buffer);
489 COPY(edge_emu_buffer);
490 COPY(me.scratchpad);
491 COPY(rd_scratchpad);
492 COPY(b_scratchpad);
493 COPY(obmc_scratchpad);
494 COPY(me.map);
495 COPY(me.score_map);
496 COPY(blocks);
497 COPY(block);
498 COPY(start_mb_y);
499 COPY(end_mb_y);
500 COPY(me.map_generation);
501 COPY(pb);
502 COPY(dct_error_sum);
da16b204
MN
503 COPY(dct_count[0]);
504 COPY(dct_count[1]);
9c3d33d6
MN
505#undef COPY
506}
507
c62c07d3 508void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
9c3d33d6 509 MpegEncContext bak;
c62c07d3 510 int i;
9c3d33d6
MN
511 //FIXME copy only needed parts
512//START_TIMER
513 backup_duplicate_context(&bak, dst);
514 memcpy(dst, src, sizeof(MpegEncContext));
515 backup_duplicate_context(dst, &bak);
c62c07d3
MN
516 for(i=0;i<12;i++){
517 dst->pblocks[i] = (short *)(&dst->block[i]);
518 }
9c3d33d6
MN
519//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
520}
521
522static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
523#define COPY(a) dst->a= src->a
524 COPY(pict_type);
525 COPY(current_picture);
526 COPY(f_code);
527 COPY(b_code);
528 COPY(qscale);
529 COPY(lambda);
530 COPY(lambda2);
531 COPY(picture_in_gop_number);
532 COPY(gop_picture_number);
533 COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
534 COPY(progressive_frame); //FIXME dont set in encode_header
535 COPY(partitioned_frame); //FIXME dont set in encode_header
536#undef COPY
537}
538
3edcacde
MN
539/**
540 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
541 * the changed fields will not depend upon the prior state of the MpegEncContext.
542 */
543static void MPV_common_defaults(MpegEncContext *s){
544 s->y_dc_scale_table=
545 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
546 s->chroma_qscale_table= ff_default_chroma_qscale_table;
547 s->progressive_frame= 1;
548 s->progressive_sequence= 1;
549 s->picture_structure= PICT_FRAME;
550
551 s->coded_picture_number = 0;
552 s->picture_number = 0;
553 s->input_picture_number = 0;
554
555 s->picture_in_gop_number = 0;
7976241a
MN
556
557 s->f_code = 1;
558 s->b_code = 1;
3edcacde
MN
559}
560
561/**
562 * sets the given MpegEncContext to defaults for decoding.
563 * the changed fields will not depend upon the prior state of the MpegEncContext.
564 */
565void MPV_decode_defaults(MpegEncContext *s){
566 MPV_common_defaults(s);
567}
568
569/**
570 * sets the given MpegEncContext to defaults for encoding.
571 * the changed fields will not depend upon the prior state of the MpegEncContext.
572 */
6b47b730
MN
573
574#ifdef CONFIG_ENCODERS
e96682e6 575static void MPV_encode_defaults(MpegEncContext *s){
3edcacde
MN
576 static int done=0;
577
578 MPV_common_defaults(s);
579
580 if(!done){
581 int i;
582 done=1;
583
584 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
585 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
586 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
587
588 for(i=-16; i<16; i++){
589 default_fcode_tab[i + MAX_MV]= 1;
590 }
591 }
592 s->me.mv_penalty= default_mv_penalty;
593 s->fcode_tab= default_fcode_tab;
594}
6b47b730 595#endif //CONFIG_ENCODERS
3edcacde
MN
596
597/**
598 * init common structure for both encoder and decoder.
599 * this assumes that some variables like width/height are already set
600 */
defdfc9a
AB
601int MPV_common_init(MpegEncContext *s)
602{
bb198e19 603 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
defdfc9a 604
844ce49d 605 if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
000a9c02
MN
606 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
607 return -1;
608 }
609
b0368839 610 dsputil_init(&s->dsp, s->avctx);
defdfc9a 611 DCT_common_init(s);
eb4b3dd3 612
9fee1e23 613 s->flags= s->avctx->flags;
303e50e6 614 s->flags2= s->avctx->flags2;
defdfc9a 615
1e491e29 616 s->mb_width = (s->width + 15) / 16;
de6d9b64 617 s->mb_height = (s->height + 15) / 16;
7bc9090a 618 s->mb_stride = s->mb_width + 1;
b40cd4e0
MN
619 s->b8_stride = s->mb_width*2 + 1;
620 s->b4_stride = s->mb_width*4 + 1;
7bc9090a 621 mb_array_size= s->mb_height * s->mb_stride;
bb198e19 622 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
eb4b3dd3 623
ffdff4d7
IK
624 /* set chroma shifts */
625 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
626 &(s->chroma_y_shift) );
627
b5a093b3
MN
628 /* set default edge pos, will be overriden in decode_header if needed */
629 s->h_edge_pos= s->mb_width*16;
630 s->v_edge_pos= s->mb_height*16;
eb4b3dd3
ZK
631
632 s->mb_num = s->mb_width * s->mb_height;
7bc9090a
MN
633
634 s->block_wrap[0]=
635 s->block_wrap[1]=
636 s->block_wrap[2]=
137c8468 637 s->block_wrap[3]= s->b8_stride;
7bc9090a 638 s->block_wrap[4]=
137c8468 639 s->block_wrap[5]= s->mb_stride;
3edcacde 640
137c8468
MN
641 y_size = s->b8_stride * (2 * s->mb_height + 1);
642 c_size = s->mb_stride * (s->mb_height + 1);
eb4b3dd3 643 yc_size = y_size + 2 * c_size;
3edcacde 644
202ef8b8 645 /* convert fourcc to upper case */
7004ffb3
MN
646 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
647 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
648 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
649 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
b5a093b3 650
541ae140
MN
651 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
652 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
653 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
654 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
655
492cd3a9 656 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
1e491e29 657
7bc9090a
MN
658 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
659 for(y=0; y<s->mb_height; y++){
660 for(x=0; x<s->mb_width; x++){
661 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
662 }
663 }
664 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
665
37fbfd0a 666 if (s->encoding) {
9dbcbd92 667 /* Allocate MV tables */
7bc9090a
MN
668 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
669 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
670 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
671 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
672 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
673 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
674 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
675 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
676 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
677 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
678 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
679 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
7f2fe444 680
6b460aa3
MN
681 if(s->msmpeg4_version){
682 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
683 }
3aa102be 684 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
7bc9090a
MN
685
686 /* Allocate MB type table */
bb198e19 687 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
158c7f05
MN
688
689 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
7e4995c3
MN
690
691 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
692 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
642ccefb
MN
693 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
694 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
9d9e3172
MN
695 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
696 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
821cb11f
MN
697
698 if(s->avctx->noise_reduction){
821cb11f
MN
699 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
700 }
37fbfd0a 701 }
b465449e
MN
702 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
703
7bc9090a 704 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
37fbfd0a 705
bb198e19 706 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
4d2858de 707 /* interlaced direct mode decoding tables */
bb198e19
MN
708 for(i=0; i<2; i++){
709 int j, k;
710 for(j=0; j<2; j++){
711 for(k=0; k<2; k++){
712 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
713 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
714 }
715 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
716 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
717 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
718 }
719 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
720 }
de6d9b64 721 }
6e2d5f1a 722 if (s->out_format == FMT_H263) {
de6d9b64 723 /* ac values */
137c8468
MN
724 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
725 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
726 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
de6d9b64
FB
727 s->ac_val[2] = s->ac_val[1] + c_size;
728
729 /* cbp values */
137c8468
MN
730 CHECKED_ALLOCZ(s->coded_block_base, y_size);
731 s->coded_block= s->coded_block_base + s->b8_stride + 1;
eec1c6b9
MN
732
733 /* divx501 bitstream reorder buffer */
7f2fe444 734 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
f01a1894 735
7f2fe444 736 /* cbp, ac_pred, pred_dir */
7bc9090a
MN
737 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
738 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
5b3438c6 739 }
8b32880c
MN
740
741 if (s->h263_pred || s->h263_plus || !s->encoding) {
742 /* dc values */
743 //MN: we need these for error resilience of intra-frames
137c8468
MN
744 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
745 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
746 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
8b32880c
MN
747 s->dc_val[2] = s->dc_val[1] + c_size;
748 for(i=0;i<yc_size;i++)
137c8468 749 s->dc_val_base[i] = 1024;
8b32880c
MN
750 }
751
7806197d 752 /* which mb is a intra block */
7bc9090a
MN
753 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
754 memset(s->mbintra_table, 1, mb_array_size);
7806197d 755
3bb4e23a 756 /* init macroblock skip table */
7bc9090a 757 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
4d2858de 758 //Note the +1 is for a quicker mpeg4 slice_end detection
f943e138 759 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
ba6802de 760
d7425f59 761 s->parse_context.state= -1;
0c9bbaec
WH
762 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
763 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
764 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
765 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
766 }
d7425f59 767
de6d9b64 768 s->context_initialized = 1;
9c3d33d6
MN
769
770 s->thread_context[0]= s;
771 for(i=1; i<s->avctx->thread_count; i++){
772 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
773 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
774 }
775
776 for(i=0; i<s->avctx->thread_count; i++){
777 if(init_duplicate_context(s->thread_context[i], s) < 0)
778 goto fail;
779 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
780 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
781 }
782
de6d9b64
FB
783 return 0;
784 fail:
8257bf05 785 MPV_common_end(s);
de6d9b64
FB
786 return -1;
787}
788
789/* init common structure for both encoder and decoder */
790void MPV_common_end(MpegEncContext *s)
791{
bb198e19 792 int i, j, k;
de6d9b64 793
9c3d33d6
MN
794 for(i=0; i<s->avctx->thread_count; i++){
795 free_duplicate_context(s->thread_context[i]);
796 }
797 for(i=1; i<s->avctx->thread_count; i++){
798 av_freep(&s->thread_context[i]);
799 }
800
147e5200
MN
801 av_freep(&s->parse_context.buffer);
802 s->parse_context.buffer_size=0;
803
6000abfa 804 av_freep(&s->mb_type);
7bc9090a
MN
805 av_freep(&s->p_mv_table_base);
806 av_freep(&s->b_forw_mv_table_base);
807 av_freep(&s->b_back_mv_table_base);
808 av_freep(&s->b_bidir_forw_mv_table_base);
809 av_freep(&s->b_bidir_back_mv_table_base);
810 av_freep(&s->b_direct_mv_table_base);
811 s->p_mv_table= NULL;
812 s->b_forw_mv_table= NULL;
813 s->b_back_mv_table= NULL;
814 s->b_bidir_forw_mv_table= NULL;
815 s->b_bidir_back_mv_table= NULL;
816 s->b_direct_mv_table= NULL;
bb198e19
MN
817 for(i=0; i<2; i++){
818 for(j=0; j<2; j++){
819 for(k=0; k<2; k++){
820 av_freep(&s->b_field_mv_table_base[i][j][k]);
821 s->b_field_mv_table[i][j][k]=NULL;
822 }
823 av_freep(&s->b_field_select_table[i][j]);
824 av_freep(&s->p_field_mv_table_base[i][j]);
825 s->p_field_mv_table[i][j]=NULL;
826 }
827 av_freep(&s->p_field_select_table[i]);
828 }
7bc9090a 829
137c8468
MN
830 av_freep(&s->dc_val_base);
831 av_freep(&s->ac_val_base);
832 av_freep(&s->coded_block_base);
6000abfa 833 av_freep(&s->mbintra_table);
7f2fe444
MN
834 av_freep(&s->cbp_table);
835 av_freep(&s->pred_dir_table);
7f2fe444 836
6000abfa 837 av_freep(&s->mbskip_table);
f943e138 838 av_freep(&s->prev_pict_types);
6000abfa 839 av_freep(&s->bitstream_buffer);
3aa102be 840 av_freep(&s->avctx->stats_out);
6b460aa3 841 av_freep(&s->ac_stats);
4d2858de 842 av_freep(&s->error_status_table);
7bc9090a 843 av_freep(&s->mb_index2xy);
158c7f05 844 av_freep(&s->lambda_table);
7e4995c3
MN
845 av_freep(&s->q_intra_matrix);
846 av_freep(&s->q_inter_matrix);
642ccefb
MN
847 av_freep(&s->q_intra_matrix16);
848 av_freep(&s->q_inter_matrix16);
9d9e3172
MN
849 av_freep(&s->input_picture);
850 av_freep(&s->reordered_input_picture);
821cb11f 851 av_freep(&s->dct_offset);
1e491e29 852
9b4b6e09
MN
853 if(s->picture){
854 for(i=0; i<MAX_PICTURE_COUNT; i++){
855 free_picture(s, &s->picture[i]);
856 }
de6d9b64 857 }
b465449e 858 av_freep(&s->picture);
de6d9b64 859 s->context_initialized = 0;
431f2172
MN
860 s->last_picture_ptr=
861 s->next_picture_ptr=
862 s->current_picture_ptr= NULL;
8100cab9 863
0c9bbaec 864 for(i=0; i<3; i++)
8100cab9 865 av_freep(&s->visualization_buffer[i]);
de6d9b64
FB
866}
867
7604246d
WH
868#ifdef CONFIG_ENCODERS
869
de6d9b64
FB
870/* init video encoder */
871int MPV_encode_init(AVCodecContext *avctx)
872{
873 MpegEncContext *s = avctx->priv_data;
22ddd60b 874 int i, dummy;
b1e6b355 875 int chroma_h_shift, chroma_v_shift;
3edcacde
MN
876
877 MPV_encode_defaults(s);
bc657ac3 878
36b58e85
RS
879 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
880
de6d9b64 881 s->bit_rate = avctx->bit_rate;
de6d9b64
FB
882 s->width = avctx->width;
883 s->height = avctx->height;
7f2fe444 884 if(avctx->gop_size > 600){
9b879566 885 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
7f2fe444
MN
886 avctx->gop_size=600;
887 }
de6d9b64 888 s->gop_size = avctx->gop_size;
477c35a9 889 s->avctx = avctx;
ba6802de 890 s->flags= avctx->flags;
303e50e6 891 s->flags2= avctx->flags2;
9dbcbd92 892 s->max_b_frames= avctx->max_b_frames;
d7e9533a 893 s->codec_id= avctx->codec->id;
7f2fe444
MN
894 s->luma_elim_threshold = avctx->luma_elim_threshold;
895 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
896 s->strict_std_compliance= avctx->strict_std_compliance;
897 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
1457ab52 898 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
87f8cab4 899 s->mpeg_quant= avctx->mpeg_quant;
ba58dabc 900 s->rtp_mode= !!avctx->rtp_payload_size;
bf266e19 901 s->intra_dc_precision= avctx->intra_dc_precision;
e4eadb4b 902
de6d9b64
FB
903 if (s->gop_size <= 1) {
904 s->intra_only = 1;
905 s->gop_size = 12;
906 } else {
907 s->intra_only = 0;
908 }
5e746b99 909
1457ab52 910 s->me_method = avctx->me_method;
5e746b99 911
e4986da9 912 /* Fixed QSCALE */
bb198e19 913 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
37fbfd0a 914
c5d309f2 915 s->adaptive_quant= ( s->avctx->lumi_masking
5e746b99 916 || s->avctx->dark_masking
c5d309f2
MN
917 || s->avctx->temporal_cplx_masking
918 || s->avctx->spatial_cplx_masking
1f26c6f3
MN
919 || s->avctx->p_masking
920 || (s->flags&CODEC_FLAG_QP_RD))
c5d309f2 921 && !s->fixed_qscale;
fcb48651 922
bb198e19
MN
923 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
924 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
925 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
5e746b99 926
273977d8
MN
927 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
928 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
929 return -1;
930 }
931
932 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
933 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
b73afeac
MN
934 }
935
23854cad
MN
936 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
937 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
938 return -1;
939 }
940
941 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
942 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
943 return -1;
944 }
945
b73afeac
MN
946 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
947 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
948 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
273977d8 949
b73afeac
MN
950 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
951 }
952
f7190f73 953 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
747a0554 954 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
9b879566 955 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
9acbbd16
MN
956 return -1;
957 }
273977d8 958
f7190f73
MN
959 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
960 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
961 return -1;
962 }
963
332f9ac4
MN
964 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
965 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
966 return -1;
967 }
968
9acbbd16 969 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
9b879566 970 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
9acbbd16
MN
971 return -1;
972 }
973
974 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
9b879566 975 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
9acbbd16
MN
976 return -1;
977 }
978
029911d1 979 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
9b879566 980 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
9acbbd16
MN
981 return -1;
982 }
1671083f
MN
983
984 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
985 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
986 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
987 return -1;
988 }
989
9acbbd16 990 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
9b879566 991 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
9acbbd16
MN
992 return -1;
993 }
e4eadb4b 994
f2f6134b 995 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
9b879566 996 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
f2f6134b
MN
997 return -1;
998 }
999
dd3e415e
MN
1000 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1001 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1002 return -1;
1003 }
1004
303e50e6
MN
1005 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1006 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1007 return -1;
1008 }
9c3d33d6
MN
1009
1010 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1011 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1012 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1013 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1014 return -1;
1015 }
1016
1017 if(s->avctx->thread_count > 1)
1018 s->rtp_mode= 1;
11a8a71d
MN
1019
1020 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1021 if(i > 1){
1022 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1023 avctx->frame_rate /= i;
1024 avctx->frame_rate_base /= i;
1025// return -1;
1026 }
303e50e6 1027
1984f635
MN
1028 if(s->codec_id==CODEC_ID_MJPEG){
1029 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1030 s->inter_quant_bias= 0;
029911d1 1031 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1984f635
MN
1032 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1033 s->inter_quant_bias= 0;
1034 }else{
1035 s->intra_quant_bias=0;
1036 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1037 }
1038
1039 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1040 s->intra_quant_bias= avctx->intra_quant_bias;
1041 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1042 s->inter_quant_bias= avctx->inter_quant_bias;
b1e6b355
MN
1043
1044 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1045
22ddd60b
MN
1046 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1047 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1048
de6d9b64
FB
1049 switch(avctx->codec->id) {
1050 case CODEC_ID_MPEG1VIDEO:
1051 s->out_format = FMT_MPEG1;
14bea432
MN
1052 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1053 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1054 break;
029911d1
MN
1055 case CODEC_ID_MPEG2VIDEO:
1056 s->out_format = FMT_MPEG1;
1057 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1058 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
ba58dabc 1059 s->rtp_mode= 1;
029911d1 1060 break;
b1e6b355 1061 case CODEC_ID_LJPEG:
de6d9b64
FB
1062 case CODEC_ID_MJPEG:
1063 s->out_format = FMT_MJPEG;
1064 s->intra_only = 1; /* force intra only for jpeg */
37fbfd0a 1065 s->mjpeg_write_tables = 1; /* write all tables */
a69b930c 1066 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
b1e6b355
MN
1067 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1068 s->mjpeg_vsample[1] = 1;
37fbfd0a 1069 s->mjpeg_vsample[2] = 1;
b1e6b355 1070 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
37fbfd0a
J
1071 s->mjpeg_hsample[1] = 1;
1072 s->mjpeg_hsample[2] = 1;
de6d9b64
FB
1073 if (mjpeg_init(s) < 0)
1074 return -1;
1ff662cc 1075 avctx->delay=0;
4e00e76b 1076 s->low_delay=1;
de6d9b64 1077 break;
1d0d55da 1078#ifdef CONFIG_RISKY
de6d9b64 1079 case CODEC_ID_H263:
37fbfd0a 1080 if (h263_get_picture_format(s->width, s->height) == 7) {
9b879566 1081 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
de6d9b64 1082 return -1;
37fbfd0a 1083 }
de6d9b64 1084 s->out_format = FMT_H263;
332f9ac4 1085 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1ff662cc 1086 avctx->delay=0;
4e00e76b 1087 s->low_delay=1;
de6d9b64
FB
1088 break;
1089 case CODEC_ID_H263P:
1090 s->out_format = FMT_H263;
1091 s->h263_plus = 1;
21e59552 1092 /* Fx */
332f9ac4 1093 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
21e59552 1094 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
332f9ac4 1095 s->modified_quant= s->h263_aic;
dba019da 1096 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
332f9ac4
MN
1097 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1098 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1099 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
ba58dabc 1100 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
332f9ac4 1101
21e59552 1102 /* /Fx */
544286b3 1103 /* These are just to be sure */
1ff662cc 1104 avctx->delay=0;
4e00e76b 1105 s->low_delay=1;
de6d9b64 1106 break;
d4f5d74a
GM
1107 case CODEC_ID_FLV1:
1108 s->out_format = FMT_H263;
1109 s->h263_flv = 2; /* format = 1; 11-bit codes */
1110 s->unrestricted_mv = 1;
1111 s->rtp_mode=0; /* don't allow GOB */
1112 avctx->delay=0;
1113 s->low_delay=1;
1114 break;
de6d9b64
FB
1115 case CODEC_ID_RV10:
1116 s->out_format = FMT_H263;
1ff662cc 1117 avctx->delay=0;
4e00e76b 1118 s->low_delay=1;
de6d9b64 1119 break;
58f26ba9 1120 case CODEC_ID_MPEG4:
de6d9b64
FB
1121 s->out_format = FMT_H263;
1122 s->h263_pred = 1;
1123 s->unrestricted_mv = 1;
4e00e76b 1124 s->low_delay= s->max_b_frames ? 0 : 1;
4d2858de 1125 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1126 break;
84afee34 1127 case CODEC_ID_MSMPEG4V1:
de6d9b64
FB
1128 s->out_format = FMT_H263;
1129 s->h263_msmpeg4 = 1;
1130 s->h263_pred = 1;
1131 s->unrestricted_mv = 1;
84afee34 1132 s->msmpeg4_version= 1;
1ff662cc 1133 avctx->delay=0;
4e00e76b 1134 s->low_delay=1;
84afee34
MN
1135 break;
1136 case CODEC_ID_MSMPEG4V2:
1137 s->out_format = FMT_H263;
1138 s->h263_msmpeg4 = 1;
1139 s->h263_pred = 1;
1140 s->unrestricted_mv = 1;
1141 s->msmpeg4_version= 2;
1ff662cc 1142 avctx->delay=0;
4e00e76b 1143 s->low_delay=1;
84afee34
MN
1144 break;
1145 case CODEC_ID_MSMPEG4V3:
1146 s->out_format = FMT_H263;
1147 s->h263_msmpeg4 = 1;
1148 s->h263_pred = 1;
1149 s->unrestricted_mv = 1;
1150 s->msmpeg4_version= 3;
1f9aea9b 1151 s->flipflop_rounding=1;
1ff662cc 1152 avctx->delay=0;
4e00e76b 1153 s->low_delay=1;
de6d9b64 1154 break;
f5957f3f
MN
1155 case CODEC_ID_WMV1:
1156 s->out_format = FMT_H263;
1157 s->h263_msmpeg4 = 1;
1158 s->h263_pred = 1;
1159 s->unrestricted_mv = 1;
1160 s->msmpeg4_version= 4;
1f9aea9b 1161 s->flipflop_rounding=1;
f5957f3f 1162 avctx->delay=0;
4e00e76b 1163 s->low_delay=1;
f5957f3f
MN
1164 break;
1165 case CODEC_ID_WMV2:
1166 s->out_format = FMT_H263;
1167 s->h263_msmpeg4 = 1;
1168 s->h263_pred = 1;
1169 s->unrestricted_mv = 1;
1170 s->msmpeg4_version= 5;
1f9aea9b 1171 s->flipflop_rounding=1;
f5957f3f 1172 avctx->delay=0;
4e00e76b 1173 s->low_delay=1;
f5957f3f 1174 break;
1d0d55da 1175#endif
de6d9b64
FB
1176 default:
1177 return -1;
1178 }
57518155
MN
1179
1180 avctx->has_b_frames= !s->low_delay;
2c492e94 1181
3bb4e23a
FB
1182 s->encoding = 1;
1183
de6d9b64
FB
1184 /* init */
1185 if (MPV_common_init(s) < 0)
1186 return -1;
dd5e90cd
MN
1187
1188 if(s->modified_quant)
1189 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1190 s->progressive_frame=
bb198e19 1191 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
9c3d33d6 1192 s->quant_precision=5;
de6d9b64 1193
622348f9
MN
1194 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1195
bbed9259 1196#ifdef CONFIG_ENCODERS
1d0d55da 1197#ifdef CONFIG_RISKY
2ad1516a
MN
1198 if (s->out_format == FMT_H263)
1199 h263_encode_init(s);
2ad1516a
MN
1200 if(s->msmpeg4_version)
1201 ff_msmpeg4_encode_init(s);
bbed9259 1202#endif
1d0d55da
MN
1203 if (s->out_format == FMT_MPEG1)
1204 ff_mpeg1_encode_init(s);
1205#endif
2ad1516a 1206
3edcacde 1207 /* init q matrix */
519c2b6d 1208 for(i=0;i<64;i++) {
b0368839 1209 int j= s->dsp.idct_permutation[i];
1d0d55da 1210#ifdef CONFIG_RISKY
87f8cab4 1211 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
2ad1516a
MN
1212 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1213 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
87f8cab4 1214 }else if(s->out_format == FMT_H263){
2ad1516a
MN
1215 s->intra_matrix[j] =
1216 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1d0d55da
MN
1217 }else
1218#endif
029911d1 1219 { /* mpeg1/2 */
2ad1516a
MN
1220 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1221 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
87f8cab4 1222 }
d6eb3c50
MN
1223 if(s->avctx->intra_matrix)
1224 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1225 if(s->avctx->inter_matrix)
1226 s->inter_matrix[j] = s->avctx->inter_matrix[i];
d7e9533a
MN
1227 }
1228
1229 /* precompute matrix */
ef5b1b5a 1230 /* for mjpeg, we do include qscale in the matrix */
d7e9533a 1231 if (s->out_format != FMT_MJPEG) {
6b56c616 1232 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
cc7ac888 1233 s->intra_matrix, s->intra_quant_bias, 1, 31);
6b56c616 1234 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
cc7ac888 1235 s->inter_matrix, s->inter_quant_bias, 1, 31);
519c2b6d
FB
1236 }
1237
8b4c7dbc
MN
1238 if(ff_rate_control_init(s) < 0)
1239 return -1;
3edcacde 1240
de6d9b64
FB
1241 return 0;
1242}
1243
1244int MPV_encode_end(AVCodecContext *avctx)
1245{
1246 MpegEncContext *s = avctx->priv_data;
1247
1248#ifdef STATS
1249 print_stats();
1250#endif
8b4c7dbc
MN
1251
1252 ff_rate_control_uninit(s);
1253
de6d9b64
FB
1254 MPV_common_end(s);
1255 if (s->out_format == FMT_MJPEG)
1256 mjpeg_close(s);
541ae140 1257
22ddd60b 1258 av_freep(&avctx->extradata);
37fbfd0a 1259
de6d9b64
FB
1260 return 0;
1261}
1262
7604246d
WH
1263#endif //CONFIG_ENCODERS
1264
1d0d55da
MN
1265void init_rl(RLTable *rl)
1266{
0c1a9eda
ZK
1267 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1268 uint8_t index_run[MAX_RUN+1];
1d0d55da
MN
1269 int last, run, level, start, end, i;
1270
1271 /* compute max_level[], max_run[] and index_run[] */
1272 for(last=0;last<2;last++) {
1273 if (last == 0) {
1274 start = 0;
1275 end = rl->last;
1276 } else {
1277 start = rl->last;
1278 end = rl->n;
1279 }
1280
1281 memset(max_level, 0, MAX_RUN + 1);
1282 memset(max_run, 0, MAX_LEVEL + 1);
1283 memset(index_run, rl->n, MAX_RUN + 1);
1284 for(i=start;i<end;i++) {
1285 run = rl->table_run[i];
1286 level = rl->table_level[i];
1287 if (index_run[run] == rl->n)
1288 index_run[run] = i;
1289 if (level > max_level[run])
1290 max_level[run] = level;
1291 if (run > max_run[level])
1292 max_run[level] = run;
1293 }
1294 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1295 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1296 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1297 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1298 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1299 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1300 }
1301}
1302
de6d9b64 1303/* draw the edges of width 'w' of an image of size width, height */
fd7db0fd 1304//FIXME check that this is ok for mpeg4 interlaced
0c1a9eda 1305static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
de6d9b64 1306{
0c1a9eda 1307 uint8_t *ptr, *last_line;
de6d9b64
FB
1308 int i;
1309
1310 last_line = buf + (height - 1) * wrap;
1311 for(i=0;i<w;i++) {
1312 /* top and bottom */
1313 memcpy(buf - (i + 1) * wrap, buf, width);
1314 memcpy(last_line + (i + 1) * wrap, last_line, width);
1315 }
1316 /* left and right */
1317 ptr = buf;
1318 for(i=0;i<height;i++) {
1319 memset(ptr - w, ptr[0], w);
1320 memset(ptr + width, ptr[width-1], w);
1321 ptr += wrap;
1322 }
1323 /* corners */
1324 for(i=0;i<w;i++) {
1325 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1326 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1327 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1328 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1329 }
1330}
1331
5f194811 1332int ff_find_unused_picture(MpegEncContext *s, int shared){
4e00e76b
MN
1333 int i;
1334
1335 if(shared){
1336 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1337 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
4e00e76b
MN
1338 }
1339 }else{
1340 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1341 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
4e00e76b
MN
1342 }
1343 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1344 if(s->picture[i].data[0]==NULL) return i;
4e00e76b
MN
1345 }
1346 }
1347
5f194811
MN
1348 assert(0);
1349 return -1;
4e00e76b
MN
1350}
1351
821cb11f
MN
1352static void update_noise_reduction(MpegEncContext *s){
1353 int intra, i;
1354
1355 for(intra=0; intra<2; intra++){
1356 if(s->dct_count[intra] > (1<<16)){
1357 for(i=0; i<64; i++){
1358 s->dct_error_sum[intra][i] >>=1;
1359 }
1360 s->dct_count[intra] >>= 1;
1361 }
1362
1363 for(i=0; i<64; i++){
1364 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1365 }
1366 }
1367}
1368
5f194811
MN
1369/**
1370 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1371 */
d6db1c9c 1372int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
de6d9b64 1373{
4e00e76b 1374 int i;
492cd3a9 1375 AVFrame *pic;
425dddb7 1376 s->mb_skiped = 0;
0da71265 1377
8b82a956 1378 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
e20c4069 1379
1e491e29 1380 /* mark&release old frames */
14e2a940 1381 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
b536d0aa 1382 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1e491e29
MN
1383
1384 /* release forgotten pictures */
1385 /* if(mpeg124/h263) */
1386 if(!s->encoding){
1387 for(i=0; i<MAX_PICTURE_COUNT; i++){
b536d0aa 1388 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
9b879566 1389 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
492cd3a9 1390 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1e491e29
MN
1391 }
1392 }
d6db1c9c 1393 }
93a21abd 1394 }
aa388dba
MN
1395alloc:
1396 if(!s->encoding){
e20c4069
MN
1397 /* release non refernce frames */
1398 for(i=0; i<MAX_PICTURE_COUNT; i++){
1399 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1400 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1401 }
1402 }
1403
5f194811
MN
1404 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1405 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1406 else{
1407 i= ff_find_unused_picture(s, 0);
1408 pic= (AVFrame*)&s->picture[i];
1409 }
1410
14e2a940 1411 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
b536d0aa 1412
1031fabd 1413 pic->coded_picture_number= s->coded_picture_number++;
1e491e29 1414
f23a68df
IK
1415 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1416 return -1;
93a21abd 1417
5f194811 1418 s->current_picture_ptr= (Picture*)pic;
c70f1716 1419 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
2be9f03a 1420 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1e491e29 1421 }
b7adc711 1422
9f2e61b6 1423 s->current_picture_ptr->pict_type= s->pict_type;
158c7f05
MN
1424// if(s->flags && CODEC_FLAG_QSCALE)
1425 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
7bc9090a 1426 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
9f2e61b6 1427
6571e41d 1428 copy_picture(&s->current_picture, s->current_picture_ptr);
9f2e61b6 1429
8b82a956 1430 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1e491e29 1431 if (s->pict_type != B_TYPE) {
b536d0aa 1432 s->last_picture_ptr= s->next_picture_ptr;
14e2a940
MN
1433 if(!s->dropable)
1434 s->next_picture_ptr= s->current_picture_ptr;
de6d9b64 1435 }
14e2a940
MN
1436/* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1437 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1438 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1439 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1440 s->pict_type, s->dropable);*/
d90cf87b 1441
6571e41d
MN
1442 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1443 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
aa388dba 1444
6571e41d 1445 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
9b879566 1446 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
ffba1dc0
MN
1447 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1448 goto alloc;
1449 }
1450
1451 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1452
b536d0aa
MN
1453 if(s->picture_structure!=PICT_FRAME){
1454 int i;
1455 for(i=0; i<4; i++){
1456 if(s->picture_structure == PICT_BOTTOM_FIELD){
1457 s->current_picture.data[i] += s->current_picture.linesize[i];
1458 }
1459 s->current_picture.linesize[i] *= 2;
1460 s->last_picture.linesize[i] *=2;
1461 s->next_picture.linesize[i] *=2;
1462 }
1463 }
0da71265 1464 }
1e491e29 1465
aa388dba
MN
1466 s->hurry_up= s->avctx->hurry_up;
1467 s->error_resilience= avctx->error_resilience;
1468
d930ef19
MN
1469 /* set dequantizer, we cant do it during init as it might change for mpeg4
1470 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
d50635cd
MN
1471 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1472 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1473 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1474 }else if(s->out_format == FMT_H263){
1475 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1476 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
c6148de2
MN
1477 }else if(s->out_format == FMT_H261){
1478 s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1479 s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
d50635cd
MN
1480 }else{
1481 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1482 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1483 }
d6db1c9c 1484
821cb11f
MN
1485 if(s->dct_error_sum){
1486 assert(s->avctx->noise_reduction && s->encoding);
1487
1488 update_noise_reduction(s);
1489 }
1490
2e7b4c84
IK
1491#ifdef HAVE_XVMC
1492 if(s->avctx->xvmc_acceleration)
1493 return XVMC_field_start(s, avctx);
1494#endif
d6db1c9c 1495 return 0;
de6d9b64 1496}
21af69f7 1497
de6d9b64
FB
1498/* generic function for encode/decode called after a frame has been coded/decoded */
1499void MPV_frame_end(MpegEncContext *s)
1500{
1e491e29 1501 int i;
de6d9b64 1502 /* draw edge for correct motion prediction if outside */
2e7b4c84
IK
1503#ifdef HAVE_XVMC
1504//just to make sure that all data is rendered.
1505 if(s->avctx->xvmc_acceleration){
1506 XVMC_field_end(s);
1507 }else
1508#endif
a573cc27 1509 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1e491e29
MN
1510 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1511 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1512 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
de6d9b64 1513 }
5975626d 1514 emms_c();
8b4c7dbc 1515
3aa102be 1516 s->last_pict_type = s->pict_type;
8b4c7dbc
MN
1517 if(s->pict_type!=B_TYPE){
1518 s->last_non_b_pict_type= s->pict_type;
8b4c7dbc 1519 }
b536d0aa
MN
1520#if 0
1521 /* copy back current_picture variables */
1e491e29
MN
1522 for(i=0; i<MAX_PICTURE_COUNT; i++){
1523 if(s->picture[i].data[0] == s->current_picture.data[0]){
1524 s->picture[i]= s->current_picture;
1525 break;
1526 }
1527 }
1528 assert(i<MAX_PICTURE_COUNT);
b536d0aa 1529#endif
1e491e29 1530
e20c4069
MN
1531 if(s->encoding){
1532 /* release non refernce frames */
1533 for(i=0; i<MAX_PICTURE_COUNT; i++){
1534 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1535 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1536 }
1537 }
1e491e29 1538 }
b536d0aa
MN
1539 // clear copies, to avoid confusion
1540#if 0
1541 memset(&s->last_picture, 0, sizeof(Picture));
1542 memset(&s->next_picture, 0, sizeof(Picture));
1543 memset(&s->current_picture, 0, sizeof(Picture));
1544#endif
de6d9b64
FB
1545}
1546
7bc9090a 1547/**
db6e7795
MN
1548 * draws an line from (ex, ey) -> (sx, sy).
1549 * @param w width of the image
1550 * @param h height of the image
1551 * @param stride stride/linesize of the image
1552 * @param color color of the arrow
1553 */
1554static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
8100cab9 1555 int t, x, y, fr, f;
db6e7795
MN
1556
1557 sx= clip(sx, 0, w-1);
1558 sy= clip(sy, 0, h-1);
1559 ex= clip(ex, 0, w-1);
1560 ey= clip(ey, 0, h-1);
1561
1562 buf[sy*stride + sx]+= color;
1563
1564 if(ABS(ex - sx) > ABS(ey - sy)){
1565 if(sx > ex){
1566 t=sx; sx=ex; ex=t;
1567 t=sy; sy=ey; ey=t;
1568 }
1569 buf+= sx + sy*stride;
1570 ex-= sx;
1571 f= ((ey-sy)<<16)/ex;
1572 for(x= 0; x <= ex; x++){
8100cab9
MN
1573 y = (x*f)>>16;
1574 fr= (x*f)&0xFFFF;
1575 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1576 buf[(y+1)*stride + x]+= (color* fr )>>16;
db6e7795
MN
1577 }
1578 }else{
1579 if(sy > ey){
1580 t=sx; sx=ex; ex=t;
1581 t=sy; sy=ey; ey=t;
1582 }
1583 buf+= sx + sy*stride;
1584 ey-= sy;
1585 if(ey) f= ((ex-sx)<<16)/ey;
1586 else f= 0;
1587 for(y= 0; y <= ey; y++){
8100cab9
MN
1588 x = (y*f)>>16;
1589 fr= (y*f)&0xFFFF;
1590 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1591 buf[y*stride + x+1]+= (color* fr )>>16;;
db6e7795
MN
1592 }
1593 }
1594}
1595
1596/**
1597 * draws an arrow from (ex, ey) -> (sx, sy).
1598 * @param w width of the image
1599 * @param h height of the image
1600 * @param stride stride/linesize of the image
1601 * @param color color of the arrow
1602 */
1603static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1604 int dx,dy;
1605
1606 sx= clip(sx, -100, w+100);
1607 sy= clip(sy, -100, h+100);
1608 ex= clip(ex, -100, w+100);
1609 ey= clip(ey, -100, h+100);
1610
1611 dx= ex - sx;
1612 dy= ey - sy;
1613
1614 if(dx*dx + dy*dy > 3*3){
1615 int rx= dx + dy;
1616 int ry= -dx + dy;
1617 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1618
1619 //FIXME subpixel accuracy
1620 rx= ROUNDED_DIV(rx*3<<4, length);
1621 ry= ROUNDED_DIV(ry*3<<4, length);
1622
1623 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1624 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1625 }
1626 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1627}
1628
1629/**
7bc9090a
MN
1630 * prints debuging info for the given picture.
1631 */
0c9bbaec 1632void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
7bc9090a
MN
1633
1634 if(!pict || !pict->mb_type) return;
1635
1636 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1637 int x,y;
0c9bbaec
WH
1638
1639 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1640 switch (pict->pict_type) {
1641 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1642 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1643 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1644 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1645 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1646 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1647 }
7bc9090a
MN
1648 for(y=0; y<s->mb_height; y++){
1649 for(x=0; x<s->mb_width; x++){
1650 if(s->avctx->debug&FF_DEBUG_SKIP){
1651 int count= s->mbskip_table[x + y*s->mb_stride];
1652 if(count>9) count=9;
9b879566 1653 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
7bc9090a
MN
1654 }
1655 if(s->avctx->debug&FF_DEBUG_QP){
9b879566 1656 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
7bc9090a
MN
1657 }
1658 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1659 int mb_type= pict->mb_type[x + y*s->mb_stride];
7bc9090a
MN
1660 //Type & MV direction
1661 if(IS_PCM(mb_type))
9b879566 1662 av_log(s->avctx, AV_LOG_DEBUG, "P");
7bc9090a 1663 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
9b879566 1664 av_log(s->avctx, AV_LOG_DEBUG, "A");
7bc9090a 1665 else if(IS_INTRA4x4(mb_type))
9b879566 1666 av_log(s->avctx, AV_LOG_DEBUG, "i");
7bc9090a 1667 else if(IS_INTRA16x16(mb_type))
9b879566 1668 av_log(s->avctx, AV_LOG_DEBUG, "I");
7bc9090a 1669 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
9b879566 1670 av_log(s->avctx, AV_LOG_DEBUG, "d");
7bc9090a 1671 else if(IS_DIRECT(mb_type))
9b879566 1672 av_log(s->avctx, AV_LOG_DEBUG, "D");
7bc9090a 1673 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
9b879566 1674 av_log(s->avctx, AV_LOG_DEBUG, "g");
7bc9090a 1675 else if(IS_GMC(mb_type))
9b879566 1676 av_log(s->avctx, AV_LOG_DEBUG, "G");
7bc9090a 1677 else if(IS_SKIP(mb_type))
9b879566 1678 av_log(s->avctx, AV_LOG_DEBUG, "S");
7bc9090a 1679 else if(!USES_LIST(mb_type, 1))
9b879566 1680 av_log(s->avctx, AV_LOG_DEBUG, ">");
7bc9090a 1681 else if(!USES_LIST(mb_type, 0))
9b879566 1682 av_log(s->avctx, AV_LOG_DEBUG, "<");
7bc9090a
MN
1683 else{
1684 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
9b879566 1685 av_log(s->avctx, AV_LOG_DEBUG, "X");
7bc9090a
MN
1686 }
1687
1688 //segmentation
1689 if(IS_8X8(mb_type))
9b879566 1690 av_log(s->avctx, AV_LOG_DEBUG, "+");
7bc9090a 1691 else if(IS_16X8(mb_type))
9b879566 1692 av_log(s->avctx, AV_LOG_DEBUG, "-");
7bc9090a 1693 else if(IS_8X16(mb_type))
9b879566 1694