lowres needs EMU_EDGE
[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;
b100eab8 863 s->linesize= s->uvlinesize= 0;
8100cab9 864
0c9bbaec 865 for(i=0; i<3; i++)
8100cab9 866 av_freep(&s->visualization_buffer[i]);
b100eab8
MN
867
868 avcodec_default_free_buffers(s->avctx);
de6d9b64
FB
869}
870
7604246d
WH
871#ifdef CONFIG_ENCODERS
872
de6d9b64
FB
873/* init video encoder */
874int MPV_encode_init(AVCodecContext *avctx)
875{
876 MpegEncContext *s = avctx->priv_data;
22ddd60b 877 int i, dummy;
b1e6b355 878 int chroma_h_shift, chroma_v_shift;
3edcacde
MN
879
880 MPV_encode_defaults(s);
bc657ac3 881
36b58e85
RS
882 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
883
de6d9b64 884 s->bit_rate = avctx->bit_rate;
de6d9b64
FB
885 s->width = avctx->width;
886 s->height = avctx->height;
7f2fe444 887 if(avctx->gop_size > 600){
9b879566 888 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
7f2fe444
MN
889 avctx->gop_size=600;
890 }
de6d9b64 891 s->gop_size = avctx->gop_size;
477c35a9 892 s->avctx = avctx;
ba6802de 893 s->flags= avctx->flags;
303e50e6 894 s->flags2= avctx->flags2;
9dbcbd92 895 s->max_b_frames= avctx->max_b_frames;
d7e9533a 896 s->codec_id= avctx->codec->id;
7f2fe444
MN
897 s->luma_elim_threshold = avctx->luma_elim_threshold;
898 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
899 s->strict_std_compliance= avctx->strict_std_compliance;
900 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
1457ab52 901 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
87f8cab4 902 s->mpeg_quant= avctx->mpeg_quant;
ba58dabc 903 s->rtp_mode= !!avctx->rtp_payload_size;
bf266e19 904 s->intra_dc_precision= avctx->intra_dc_precision;
9ebb8e11 905 s->user_specified_pts = AV_NOPTS_VALUE;
e4eadb4b 906
de6d9b64
FB
907 if (s->gop_size <= 1) {
908 s->intra_only = 1;
909 s->gop_size = 12;
910 } else {
911 s->intra_only = 0;
912 }
5e746b99 913
1457ab52 914 s->me_method = avctx->me_method;
5e746b99 915
e4986da9 916 /* Fixed QSCALE */
bb198e19 917 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
37fbfd0a 918
c5d309f2 919 s->adaptive_quant= ( s->avctx->lumi_masking
5e746b99 920 || s->avctx->dark_masking
c5d309f2
MN
921 || s->avctx->temporal_cplx_masking
922 || s->avctx->spatial_cplx_masking
1f26c6f3
MN
923 || s->avctx->p_masking
924 || (s->flags&CODEC_FLAG_QP_RD))
c5d309f2 925 && !s->fixed_qscale;
fcb48651 926
bb198e19
MN
927 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
928 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
929 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
5e746b99 930
273977d8
MN
931 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
932 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
933 return -1;
934 }
935
936 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
937 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
b73afeac
MN
938 }
939
23854cad
MN
940 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
941 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
942 return -1;
943 }
944
945 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
946 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
947 return -1;
948 }
949
b73afeac
MN
950 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
951 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
952 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
273977d8 953
b73afeac
MN
954 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");
955 }
956
f7190f73 957 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
747a0554 958 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
9b879566 959 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
9acbbd16
MN
960 return -1;
961 }
273977d8 962
f7190f73
MN
963 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
964 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
965 return -1;
966 }
967
332f9ac4
MN
968 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
969 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
970 return -1;
971 }
972
9acbbd16 973 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
9b879566 974 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
9acbbd16
MN
975 return -1;
976 }
977
978 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
9b879566 979 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
9acbbd16
MN
980 return -1;
981 }
982
029911d1 983 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
9b879566 984 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
9acbbd16
MN
985 return -1;
986 }
1671083f
MN
987
988 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
989 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
990 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
991 return -1;
992 }
993
9acbbd16 994 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
9b879566 995 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
9acbbd16
MN
996 return -1;
997 }
e4eadb4b 998
f2f6134b 999 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
9b879566 1000 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
f2f6134b
MN
1001 return -1;
1002 }
1003
dd3e415e
MN
1004 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1005 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1006 return -1;
1007 }
1008
303e50e6
MN
1009 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1010 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1011 return -1;
1012 }
9c3d33d6
MN
1013
1014 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1015 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1016 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1017 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1018 return -1;
1019 }
1020
1021 if(s->avctx->thread_count > 1)
1022 s->rtp_mode= 1;
11a8a71d
MN
1023
1024 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1025 if(i > 1){
1026 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1027 avctx->frame_rate /= i;
1028 avctx->frame_rate_base /= i;
1029// return -1;
1030 }
303e50e6 1031
1984f635
MN
1032 if(s->codec_id==CODEC_ID_MJPEG){
1033 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1034 s->inter_quant_bias= 0;
029911d1 1035 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1984f635
MN
1036 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1037 s->inter_quant_bias= 0;
1038 }else{
1039 s->intra_quant_bias=0;
1040 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1041 }
1042
1043 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1044 s->intra_quant_bias= avctx->intra_quant_bias;
1045 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1046 s->inter_quant_bias= avctx->inter_quant_bias;
b1e6b355
MN
1047
1048 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1049
22ddd60b
MN
1050 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1051 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1052
de6d9b64
FB
1053 switch(avctx->codec->id) {
1054 case CODEC_ID_MPEG1VIDEO:
1055 s->out_format = FMT_MPEG1;
14bea432
MN
1056 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1057 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1058 break;
029911d1
MN
1059 case CODEC_ID_MPEG2VIDEO:
1060 s->out_format = FMT_MPEG1;
1061 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1062 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
ba58dabc 1063 s->rtp_mode= 1;
029911d1 1064 break;
b1e6b355 1065 case CODEC_ID_LJPEG:
de6d9b64
FB
1066 case CODEC_ID_MJPEG:
1067 s->out_format = FMT_MJPEG;
1068 s->intra_only = 1; /* force intra only for jpeg */
37fbfd0a 1069 s->mjpeg_write_tables = 1; /* write all tables */
a69b930c 1070 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
b1e6b355
MN
1071 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1072 s->mjpeg_vsample[1] = 1;
37fbfd0a 1073 s->mjpeg_vsample[2] = 1;
b1e6b355 1074 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
37fbfd0a
J
1075 s->mjpeg_hsample[1] = 1;
1076 s->mjpeg_hsample[2] = 1;
de6d9b64
FB
1077 if (mjpeg_init(s) < 0)
1078 return -1;
1ff662cc 1079 avctx->delay=0;
4e00e76b 1080 s->low_delay=1;
de6d9b64 1081 break;
1d0d55da 1082#ifdef CONFIG_RISKY
de6d9b64 1083 case CODEC_ID_H263:
37fbfd0a 1084 if (h263_get_picture_format(s->width, s->height) == 7) {
9b879566 1085 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
de6d9b64 1086 return -1;
37fbfd0a 1087 }
de6d9b64 1088 s->out_format = FMT_H263;
332f9ac4 1089 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1ff662cc 1090 avctx->delay=0;
4e00e76b 1091 s->low_delay=1;
de6d9b64
FB
1092 break;
1093 case CODEC_ID_H263P:
1094 s->out_format = FMT_H263;
1095 s->h263_plus = 1;
21e59552 1096 /* Fx */
332f9ac4 1097 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
21e59552 1098 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
332f9ac4 1099 s->modified_quant= s->h263_aic;
dba019da 1100 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
332f9ac4
MN
1101 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1102 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1103 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
ba58dabc 1104 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
332f9ac4 1105
21e59552 1106 /* /Fx */
544286b3 1107 /* These are just to be sure */
1ff662cc 1108 avctx->delay=0;
4e00e76b 1109 s->low_delay=1;
de6d9b64 1110 break;
d4f5d74a
GM
1111 case CODEC_ID_FLV1:
1112 s->out_format = FMT_H263;
1113 s->h263_flv = 2; /* format = 1; 11-bit codes */
1114 s->unrestricted_mv = 1;
1115 s->rtp_mode=0; /* don't allow GOB */
1116 avctx->delay=0;
1117 s->low_delay=1;
1118 break;
de6d9b64
FB
1119 case CODEC_ID_RV10:
1120 s->out_format = FMT_H263;
1ff662cc 1121 avctx->delay=0;
4e00e76b 1122 s->low_delay=1;
de6d9b64 1123 break;
58f26ba9 1124 case CODEC_ID_MPEG4:
de6d9b64
FB
1125 s->out_format = FMT_H263;
1126 s->h263_pred = 1;
1127 s->unrestricted_mv = 1;
4e00e76b 1128 s->low_delay= s->max_b_frames ? 0 : 1;
4d2858de 1129 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1130 break;
84afee34 1131 case CODEC_ID_MSMPEG4V1:
de6d9b64
FB
1132 s->out_format = FMT_H263;
1133 s->h263_msmpeg4 = 1;
1134 s->h263_pred = 1;
1135 s->unrestricted_mv = 1;
84afee34 1136 s->msmpeg4_version= 1;
1ff662cc 1137 avctx->delay=0;
4e00e76b 1138 s->low_delay=1;
84afee34
MN
1139 break;
1140 case CODEC_ID_MSMPEG4V2:
1141 s->out_format = FMT_H263;
1142 s->h263_msmpeg4 = 1;
1143 s->h263_pred = 1;
1144 s->unrestricted_mv = 1;
1145 s->msmpeg4_version= 2;
1ff662cc 1146 avctx->delay=0;
4e00e76b 1147 s->low_delay=1;
84afee34
MN
1148 break;
1149 case CODEC_ID_MSMPEG4V3:
1150 s->out_format = FMT_H263;
1151 s->h263_msmpeg4 = 1;
1152 s->h263_pred = 1;
1153 s->unrestricted_mv = 1;
1154 s->msmpeg4_version= 3;
1f9aea9b 1155 s->flipflop_rounding=1;
1ff662cc 1156 avctx->delay=0;
4e00e76b 1157 s->low_delay=1;
de6d9b64 1158 break;
f5957f3f
MN
1159 case CODEC_ID_WMV1:
1160 s->out_format = FMT_H263;
1161 s->h263_msmpeg4 = 1;
1162 s->h263_pred = 1;
1163 s->unrestricted_mv = 1;
1164 s->msmpeg4_version= 4;
1f9aea9b 1165 s->flipflop_rounding=1;
f5957f3f 1166 avctx->delay=0;
4e00e76b 1167 s->low_delay=1;
f5957f3f
MN
1168 break;
1169 case CODEC_ID_WMV2:
1170 s->out_format = FMT_H263;
1171 s->h263_msmpeg4 = 1;
1172 s->h263_pred = 1;
1173 s->unrestricted_mv = 1;
1174 s->msmpeg4_version= 5;
1f9aea9b 1175 s->flipflop_rounding=1;
f5957f3f 1176 avctx->delay=0;
4e00e76b 1177 s->low_delay=1;
f5957f3f 1178 break;
1d0d55da 1179#endif
de6d9b64
FB
1180 default:
1181 return -1;
1182 }
57518155
MN
1183
1184 avctx->has_b_frames= !s->low_delay;
2c492e94 1185
3bb4e23a
FB
1186 s->encoding = 1;
1187
de6d9b64
FB
1188 /* init */
1189 if (MPV_common_init(s) < 0)
1190 return -1;
dd5e90cd
MN
1191
1192 if(s->modified_quant)
1193 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1194 s->progressive_frame=
bb198e19 1195 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
9c3d33d6 1196 s->quant_precision=5;
de6d9b64 1197
622348f9
MN
1198 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1199
bbed9259 1200#ifdef CONFIG_ENCODERS
1d0d55da 1201#ifdef CONFIG_RISKY
2ad1516a
MN
1202 if (s->out_format == FMT_H263)
1203 h263_encode_init(s);
2ad1516a
MN
1204 if(s->msmpeg4_version)
1205 ff_msmpeg4_encode_init(s);
bbed9259 1206#endif
1d0d55da
MN
1207 if (s->out_format == FMT_MPEG1)
1208 ff_mpeg1_encode_init(s);
1209#endif
2ad1516a 1210
3edcacde 1211 /* init q matrix */
519c2b6d 1212 for(i=0;i<64;i++) {
b0368839 1213 int j= s->dsp.idct_permutation[i];
1d0d55da 1214#ifdef CONFIG_RISKY
87f8cab4 1215 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
2ad1516a
MN
1216 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1217 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
87f8cab4 1218 }else if(s->out_format == FMT_H263){
2ad1516a
MN
1219 s->intra_matrix[j] =
1220 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1d0d55da
MN
1221 }else
1222#endif
029911d1 1223 { /* mpeg1/2 */
2ad1516a
MN
1224 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1225 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
87f8cab4 1226 }
d6eb3c50
MN
1227 if(s->avctx->intra_matrix)
1228 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1229 if(s->avctx->inter_matrix)
1230 s->inter_matrix[j] = s->avctx->inter_matrix[i];
d7e9533a
MN
1231 }
1232
1233 /* precompute matrix */
ef5b1b5a 1234 /* for mjpeg, we do include qscale in the matrix */
d7e9533a 1235 if (s->out_format != FMT_MJPEG) {
6b56c616 1236 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
cc7ac888 1237 s->intra_matrix, s->intra_quant_bias, 1, 31);
6b56c616 1238 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
cc7ac888 1239 s->inter_matrix, s->inter_quant_bias, 1, 31);
519c2b6d
FB
1240 }
1241
8b4c7dbc
MN
1242 if(ff_rate_control_init(s) < 0)
1243 return -1;
3edcacde 1244
de6d9b64
FB
1245 return 0;
1246}
1247
1248int MPV_encode_end(AVCodecContext *avctx)
1249{
1250 MpegEncContext *s = avctx->priv_data;
1251
1252#ifdef STATS
1253 print_stats();
1254#endif
8b4c7dbc
MN
1255
1256 ff_rate_control_uninit(s);
1257
de6d9b64
FB
1258 MPV_common_end(s);
1259 if (s->out_format == FMT_MJPEG)
1260 mjpeg_close(s);
541ae140 1261
22ddd60b 1262 av_freep(&avctx->extradata);
37fbfd0a 1263
de6d9b64
FB
1264 return 0;
1265}
1266
7604246d
WH
1267#endif //CONFIG_ENCODERS
1268
1d0d55da
MN
1269void init_rl(RLTable *rl)
1270{
0c1a9eda
ZK
1271 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1272 uint8_t index_run[MAX_RUN+1];
1d0d55da
MN
1273 int last, run, level, start, end, i;
1274
1275 /* compute max_level[], max_run[] and index_run[] */
1276 for(last=0;last<2;last++) {
1277 if (last == 0) {
1278 start = 0;
1279 end = rl->last;
1280 } else {
1281 start = rl->last;
1282 end = rl->n;
1283 }
1284
1285 memset(max_level, 0, MAX_RUN + 1);
1286 memset(max_run, 0, MAX_LEVEL + 1);
1287 memset(index_run, rl->n, MAX_RUN + 1);
1288 for(i=start;i<end;i++) {
1289 run = rl->table_run[i];
1290 level = rl->table_level[i];
1291 if (index_run[run] == rl->n)
1292 index_run[run] = i;
1293 if (level > max_level[run])
1294 max_level[run] = level;
1295 if (run > max_run[level])
1296 max_run[level] = run;
1297 }
1298 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1299 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1300 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1301 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1302 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1303 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1304 }
1305}
1306
de6d9b64 1307/* draw the edges of width 'w' of an image of size width, height */
fd7db0fd 1308//FIXME check that this is ok for mpeg4 interlaced
0c1a9eda 1309static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
de6d9b64 1310{
0c1a9eda 1311 uint8_t *ptr, *last_line;
de6d9b64
FB
1312 int i;
1313
1314 last_line = buf + (height - 1) * wrap;
1315 for(i=0;i<w;i++) {
1316 /* top and bottom */
1317 memcpy(buf - (i + 1) * wrap, buf, width);
1318 memcpy(last_line + (i + 1) * wrap, last_line, width);
1319 }
1320 /* left and right */
1321 ptr = buf;
1322 for(i=0;i<height;i++) {
1323 memset(ptr - w, ptr[0], w);
1324 memset(ptr + width, ptr[width-1], w);
1325 ptr += wrap;
1326 }
1327 /* corners */
1328 for(i=0;i<w;i++) {
1329 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1330 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1331 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1332 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1333 }
1334}
1335
5f194811 1336int ff_find_unused_picture(MpegEncContext *s, int shared){
4e00e76b
MN
1337 int i;
1338
1339 if(shared){
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;
4e00e76b
MN
1342 }
1343 }else{
1344 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1345 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
4e00e76b
MN
1346 }
1347 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1348 if(s->picture[i].data[0]==NULL) return i;
4e00e76b
MN
1349 }
1350 }
1351
5f194811
MN
1352 assert(0);
1353 return -1;
4e00e76b
MN
1354}
1355
821cb11f
MN
1356static void update_noise_reduction(MpegEncContext *s){
1357 int intra, i;
1358
1359 for(intra=0; intra<2; intra++){
1360 if(s->dct_count[intra] > (1<<16)){
1361 for(i=0; i<64; i++){
1362 s->dct_error_sum[intra][i] >>=1;
1363 }
1364 s->dct_count[intra] >>= 1;
1365 }
1366
1367 for(i=0; i<64; i++){
1368 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);
1369 }
1370 }
1371}
1372
5f194811
MN
1373/**
1374 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1375 */
d6db1c9c 1376int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
de6d9b64 1377{
4e00e76b 1378 int i;
492cd3a9 1379 AVFrame *pic;
425dddb7 1380 s->mb_skiped = 0;
0da71265 1381
8b82a956 1382 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
e20c4069 1383
1e491e29 1384 /* mark&release old frames */
14e2a940 1385 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 1386 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1e491e29
MN
1387
1388 /* release forgotten pictures */
1389 /* if(mpeg124/h263) */
1390 if(!s->encoding){
1391 for(i=0; i<MAX_PICTURE_COUNT; i++){
b536d0aa 1392 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
9b879566 1393 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
492cd3a9 1394 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1e491e29
MN
1395 }
1396 }
d6db1c9c 1397 }
93a21abd 1398 }
aa388dba
MN
1399alloc:
1400 if(!s->encoding){
e20c4069
MN
1401 /* release non refernce frames */
1402 for(i=0; i<MAX_PICTURE_COUNT; i++){
1403 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1404 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1405 }
1406 }
1407
5f194811
MN
1408 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1409 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1410 else{
1411 i= ff_find_unused_picture(s, 0);
1412 pic= (AVFrame*)&s->picture[i];
1413 }
1414
14e2a940 1415 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
b536d0aa 1416
1031fabd 1417 pic->coded_picture_number= s->coded_picture_number++;
1e491e29 1418
f23a68df
IK
1419 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1420 return -1;
93a21abd 1421
5f194811 1422 s->current_picture_ptr= (Picture*)pic;
c70f1716 1423 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
2be9f03a 1424 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1e491e29 1425 }
b7adc711 1426
9f2e61b6 1427 s->current_picture_ptr->pict_type= s->pict_type;
158c7f05
MN
1428// if(s->flags && CODEC_FLAG_QSCALE)
1429 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
7bc9090a 1430 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
9f2e61b6 1431
6571e41d 1432 copy_picture(&s->current_picture, s->current_picture_ptr);
9f2e61b6 1433
8b82a956 1434 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1e491e29 1435 if (s->pict_type != B_TYPE) {
b536d0aa 1436 s->last_picture_ptr= s->next_picture_ptr;
14e2a940
MN
1437 if(!s->dropable)
1438 s->next_picture_ptr= s->current_picture_ptr;
de6d9b64 1439 }
14e2a940
MN
1440/* 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,
1441 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1442 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1443 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1444 s->pict_type, s->dropable);*/
d90cf87b 1445
6571e41d
MN
1446 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1447 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
aa388dba 1448
6571e41d 1449 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
9b879566 1450 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
ffba1dc0
MN
1451 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1452 goto alloc;
1453 }
1454
1455 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1456
b536d0aa
MN
1457 if(s->picture_structure!=PICT_FRAME){
1458 int i;
1459 for(i=0; i<4; i++){
1460 if(s->picture_structure == PICT_BOTTOM_FIELD){
1461 s->current_picture.data[i] += s->current_picture.linesize[i];
1462 }
1463 s->current_picture.linesize[i] *= 2;
1464 s->last_picture.linesize[i] *=2;
1465 s->next_picture.linesize[i] *=2;
1466 }
1467 }
0da71265 1468 }
1e491e29 1469
aa388dba
MN
1470 s->hurry_up= s->avctx->hurry_up;
1471 s->error_resilience= avctx->error_resilience;
1472
d930ef19
MN
1473 /* set dequantizer, we cant do it during init as it might change for mpeg4
1474 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
d50635cd
MN
1475 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1476 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1477 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1478 }else if(s->out_format == FMT_H263){
1479 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1480 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
c6148de2
MN
1481 }else if(s->out_format == FMT_H261){
1482 s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1483 s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
d50635cd
MN
1484 }else{
1485 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1486 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1487 }
d6db1c9c 1488
821cb11f
MN
1489 if(s->dct_error_sum){
1490 assert(s->avctx->noise_reduction && s->encoding);
1491
1492 update_noise_reduction(s);
1493 }
1494
2e7b4c84
IK
1495#ifdef HAVE_XVMC
1496 if(s->avctx->xvmc_acceleration)
1497 return XVMC_field_start(s, avctx);
1498#endif
d6db1c9c 1499 return 0;
de6d9b64 1500}
21af69f7 1501
de6d9b64
FB
1502/* generic function for encode/decode called after a frame has been coded/decoded */
1503void MPV_frame_end(MpegEncContext *s)
1504{
1e491e29 1505 int i;
de6d9b64 1506 /* draw edge for correct motion prediction if outside */
2e7b4c84
IK
1507#ifdef HAVE_XVMC
1508//just to make sure that all data is rendered.
1509 if(s->avctx->xvmc_acceleration){
1510 XVMC_field_end(s);
1511 }else
1512#endif
a573cc27 1513 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1e491e29
MN
1514 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1515 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1516 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
de6d9b64 1517 }
5975626d 1518 emms_c();
8b4c7dbc 1519
3aa102be 1520 s->last_pict_type = s->pict_type;
8b4c7dbc
MN
1521 if(s->pict_type!=B_TYPE){
1522 s->last_non_b_pict_type= s->pict_type;
8b4c7dbc 1523 }
b536d0aa
MN
1524#if 0
1525 /* copy back current_picture variables */
1e491e29
MN
1526 for(i=0; i<MAX_PICTURE_COUNT; i++){
1527 if(s->picture[i].data[0] == s->current_picture.data[0]){
1528 s->picture[i]= s->current_picture;
1529 break;
1530 }
1531 }
1532 assert(i<MAX_PICTURE_COUNT);
b536d0aa 1533#endif
1e491e29 1534
e20c4069
MN
1535 if(s->encoding){
1536 /* release non refernce frames */
1537 for(i=0; i<MAX_PICTURE_COUNT; i++){
1538 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1539 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1540 }
1541 }
1e491e29 1542 }
b536d0aa
MN
1543 // clear copies, to avoid confusion
1544#if 0
1545 memset(&s->last_picture, 0, sizeof(Picture));
1546 memset(&s->next_picture, 0, sizeof(Picture));
1547 memset(&s->current_picture, 0, sizeof(Picture));
1548#endif
7b37a6e9 1549 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
de6d9b64
FB
1550}
1551
7bc9090a 1552/**
db6e7795
MN
1553 * draws an line from (ex, ey) -> (sx, sy).
1554 * @param w width of the image
1555 * @param h height of the image
1556 * @param stride stride/linesize of the image
1557 * @param color color of the arrow
1558 */
1559static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
8100cab9 1560 int t, x, y, fr, f;
db6e7795
MN
1561
1562 sx= clip(sx, 0, w-1);
1563 sy= clip(sy, 0, h-1);
1564 ex= clip(ex, 0, w-1);
1565 ey= clip(ey, 0, h-1);
1566
1567 buf[sy*stride + sx]+= color;
1568
1569 if(ABS(ex - sx) > ABS(ey - sy)){
1570 if(sx > ex){
1571 t=sx; sx=ex; ex=t;
1572 t=sy; sy=ey; ey=t;
1573 }
1574 buf+= sx + sy*stride;
1575 ex-= sx;
1576 f= ((ey-sy)<<16)/ex;
1577 for(x= 0; x <= ex; x++){
8100cab9
MN
1578 y = (x*f)>>16;
1579 fr= (x*f)&0xFFFF;
1580 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1581 buf[(y+1)*stride + x]+= (color* fr )>>16;
db6e7795
MN
1582 }
1583 }else{
1584 if(sy > ey){
1585 t=sx; sx=ex; ex=t;
1586 t=sy; sy=ey; ey=t;
1587 }
1588 buf+= sx + sy*stride;
1589 ey-= sy;
1590 if(ey) f= ((ex-sx)<<16)/ey;
1591 else f= 0;
1592 for(y= 0; y <= ey; y++){
8100cab9
MN
1593 x = (y*f)>>16;
1594 fr= (y*f)&0xFFFF;
1595 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1596 buf[y*stride + x+1]+= (color* fr )>>16;;
db6e7795
MN
1597 }
1598 }
1599}
1600
1601/**
1602 * draws an arrow from (ex, ey) -> (sx, sy).
1603 * @param w width of the image
1604 * @param h height of the image
1605 * @param stride stride/linesize of the image
1606 * @param color color of the arrow
1607 */
1608static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1609 int dx,dy;
1610
1611 sx= clip(sx, -100, w+100);
1612 sy= clip(sy, -100, h+100);
1613 ex= clip(ex, -100, w+100);
1614 ey= clip(ey, -100, h+100);
1615
1616 dx= ex - sx;
1617 dy= ey - sy;
1618
1619 if(dx*dx + dy*dy > 3*3){
1620 int rx= dx + dy;
1621 int ry= -dx + dy;
1622 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1623
1624 //FIXME subpixel accuracy
1625 rx= ROUNDED_DIV(rx*3<<4, length);
1626 ry= ROUNDED_DIV(ry*3<<4, length);
1627
1628 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1629 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1630 }
1631 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1632}
1633
1634/**
7bc9090a
MN
1635 * prints debuging info for the given picture.
1636 */
0c9bbaec 1637void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
7bc9090a
MN
1638
1639 if(!pict || !pict->mb_type) return;
1640
1641 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1642 int x,y;
0c9bbaec
WH
1643
1644 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1645 switch (pict->pict_type) {
1646 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1647 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1648 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1649 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1650 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1651 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1652 }
7bc9090a
MN
1653 for(y=0; y<s->mb_height; y++){
1654 for(x=0; x<s->mb_width; x++){
1655 if(s->avctx->debug&FF_DEBUG_SKIP){
1656 int count= s->mbskip_table[x + y*s->mb_stride];
1657 if(count>9) count=9;
9b879566 1658 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
7bc9090a
MN
1659 }
1660 if(s->avctx->debug&FF_DEBUG_QP){
9b879566 1661 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
7bc9090a
MN
1662 }
1663 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1664 int mb_type= pict->mb_type[x + y*s->mb_stride];
7bc9090a
MN
1665 //Type & MV direction
1666 if(IS_PCM(mb_type))
9b879566 1667 av_log(s->avctx, AV_LOG_DEBUG, "P");
7bc9090a 1668 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
9b879566 1669 av_log(s->avctx, AV_LOG_DEBUG, "A");
7bc9090a 1670 else if(IS_INTRA4x4(mb_type))
9b879566 1671 av_log(s->avctx, AV_LOG_DEBUG, "i");
7bc9090a 1672 else if(IS_INTRA16x16(mb_type))
9b879566 1673 av_log(s->avctx, AV_LOG_DEBUG, "I");
7bc9090a 1674 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
9b879566 1675 av_log(s->avctx, AV_LOG_DEBUG, "d");
7bc9090a 1676 else if(IS_DIRECT(mb_type))
9b879566 1677 av_log(s->avctx, AV_LOG_DEBUG, "D");
7bc9090a 1678 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
9b879566 1679 av_log(s->avctx, AV_LOG_DEBUG, "g");
7bc9090a 1680 else if(IS_GMC(mb_type))
9b879566 1681 av_log(s->avctx, AV_LOG_DEBUG, "G");
7bc9090a 1682 else if(IS_SKIP(mb_type))
9b879566 1683 av_log(s->avctx, AV_LOG_DEBUG, "S");
7bc9090a 1684 else if(!USES_LIST(mb_type, 1))
9b879566 1685 av_log(s->avctx, AV_LOG_DEBUG, ">");
7bc9090a 1686 else if(!USES_LIST(mb_type, 0))
9b879566 1687 av_log(s->avctx, AV_LOG_DEBUG, "<");
7bc9090a
MN
1688 else{
1689 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
9b879566 1690 av_log(s->avctx, AV_LOG_DEBUG, "X");
7bc9090a
MN
1691 }
1692
1693 //segmentation
1694 if(IS_8X8(mb_type))
9b879566 1695 av_log(s->avctx, AV_LOG_DEBUG, "+");
7bc9090a 1696 else if(IS_16X8(mb_type))
9b879566 1697 av_log(s->avctx, AV_LOG_DEBUG, "-");
7bc9090a 1698 else if(IS_8X16(mb_type))
9b879566 1699