h261 decoder by (Maarten Daniels <maarten.daniels at student dot luc dot ac dot be>)
[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()
ae35f5e1 448 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*2*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
b5a093b3
MN
624 /* set default edge pos, will be overriden in decode_header if needed */
625 s->h_edge_pos= s->mb_width*16;
626 s->v_edge_pos= s->mb_height*16;
eb4b3dd3
ZK
627
628 s->mb_num = s->mb_width * s->mb_height;
7bc9090a
MN
629
630 s->block_wrap[0]=
631 s->block_wrap[1]=
632 s->block_wrap[2]=
137c8468 633 s->block_wrap[3]= s->b8_stride;
7bc9090a 634 s->block_wrap[4]=
137c8468 635 s->block_wrap[5]= s->mb_stride;
3edcacde 636
137c8468
MN
637 y_size = s->b8_stride * (2 * s->mb_height + 1);
638 c_size = s->mb_stride * (s->mb_height + 1);
eb4b3dd3 639 yc_size = y_size + 2 * c_size;
3edcacde 640
202ef8b8 641 /* convert fourcc to upper case */
7004ffb3
MN
642 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
643 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
644 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
645 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
b5a093b3 646
541ae140
MN
647 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
648 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
649 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
650 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
651
492cd3a9 652 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
1e491e29 653
7bc9090a
MN
654 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
655 for(y=0; y<s->mb_height; y++){
656 for(x=0; x<s->mb_width; x++){
657 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
658 }
659 }
660 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
661
37fbfd0a 662 if (s->encoding) {
9dbcbd92 663 /* Allocate MV tables */
7bc9090a
MN
664 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
665 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
666 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
667 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
668 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
669 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
670 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
671 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
672 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
673 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
674 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
675 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
7f2fe444 676
6b460aa3
MN
677 if(s->msmpeg4_version){
678 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
679 }
3aa102be 680 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
7bc9090a
MN
681
682 /* Allocate MB type table */
bb198e19 683 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
158c7f05
MN
684
685 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
7e4995c3
MN
686
687 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
688 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
642ccefb
MN
689 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
690 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
9d9e3172
MN
691 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
692 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
821cb11f
MN
693
694 if(s->avctx->noise_reduction){
821cb11f
MN
695 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
696 }
37fbfd0a 697 }
b465449e
MN
698 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
699
7bc9090a 700 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
37fbfd0a 701
bb198e19 702 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
4d2858de 703 /* interlaced direct mode decoding tables */
bb198e19
MN
704 for(i=0; i<2; i++){
705 int j, k;
706 for(j=0; j<2; j++){
707 for(k=0; k<2; k++){
708 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
709 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
710 }
711 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
712 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
713 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
714 }
715 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
716 }
de6d9b64 717 }
6e2d5f1a 718 if (s->out_format == FMT_H263) {
de6d9b64 719 /* ac values */
137c8468
MN
720 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
721 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
722 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
de6d9b64
FB
723 s->ac_val[2] = s->ac_val[1] + c_size;
724
725 /* cbp values */
137c8468
MN
726 CHECKED_ALLOCZ(s->coded_block_base, y_size);
727 s->coded_block= s->coded_block_base + s->b8_stride + 1;
eec1c6b9
MN
728
729 /* divx501 bitstream reorder buffer */
7f2fe444 730 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
f01a1894 731
7f2fe444 732 /* cbp, ac_pred, pred_dir */
7bc9090a
MN
733 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
734 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
5b3438c6 735 }
8b32880c
MN
736
737 if (s->h263_pred || s->h263_plus || !s->encoding) {
738 /* dc values */
739 //MN: we need these for error resilience of intra-frames
137c8468
MN
740 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
741 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
742 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
8b32880c
MN
743 s->dc_val[2] = s->dc_val[1] + c_size;
744 for(i=0;i<yc_size;i++)
137c8468 745 s->dc_val_base[i] = 1024;
8b32880c
MN
746 }
747
7806197d 748 /* which mb is a intra block */
7bc9090a
MN
749 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
750 memset(s->mbintra_table, 1, mb_array_size);
7806197d 751
3bb4e23a 752 /* init macroblock skip table */
7bc9090a 753 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
4d2858de 754 //Note the +1 is for a quicker mpeg4 slice_end detection
f943e138 755 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
ba6802de 756
d7425f59 757 s->parse_context.state= -1;
0c9bbaec
WH
758 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
759 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
760 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
761 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
762 }
d7425f59 763
de6d9b64 764 s->context_initialized = 1;
9c3d33d6
MN
765
766 s->thread_context[0]= s;
767 for(i=1; i<s->avctx->thread_count; i++){
768 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
769 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
770 }
771
772 for(i=0; i<s->avctx->thread_count; i++){
773 if(init_duplicate_context(s->thread_context[i], s) < 0)
774 goto fail;
775 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
776 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
777 }
778
de6d9b64
FB
779 return 0;
780 fail:
8257bf05 781 MPV_common_end(s);
de6d9b64
FB
782 return -1;
783}
784
785/* init common structure for both encoder and decoder */
786void MPV_common_end(MpegEncContext *s)
787{
bb198e19 788 int i, j, k;
de6d9b64 789
9c3d33d6
MN
790 for(i=0; i<s->avctx->thread_count; i++){
791 free_duplicate_context(s->thread_context[i]);
792 }
793 for(i=1; i<s->avctx->thread_count; i++){
794 av_freep(&s->thread_context[i]);
795 }
796
147e5200
MN
797 av_freep(&s->parse_context.buffer);
798 s->parse_context.buffer_size=0;
799
6000abfa 800 av_freep(&s->mb_type);
7bc9090a
MN
801 av_freep(&s->p_mv_table_base);
802 av_freep(&s->b_forw_mv_table_base);
803 av_freep(&s->b_back_mv_table_base);
804 av_freep(&s->b_bidir_forw_mv_table_base);
805 av_freep(&s->b_bidir_back_mv_table_base);
806 av_freep(&s->b_direct_mv_table_base);
807 s->p_mv_table= NULL;
808 s->b_forw_mv_table= NULL;
809 s->b_back_mv_table= NULL;
810 s->b_bidir_forw_mv_table= NULL;
811 s->b_bidir_back_mv_table= NULL;
812 s->b_direct_mv_table= NULL;
bb198e19
MN
813 for(i=0; i<2; i++){
814 for(j=0; j<2; j++){
815 for(k=0; k<2; k++){
816 av_freep(&s->b_field_mv_table_base[i][j][k]);
817 s->b_field_mv_table[i][j][k]=NULL;
818 }
819 av_freep(&s->b_field_select_table[i][j]);
820 av_freep(&s->p_field_mv_table_base[i][j]);
821 s->p_field_mv_table[i][j]=NULL;
822 }
823 av_freep(&s->p_field_select_table[i]);
824 }
7bc9090a 825
137c8468
MN
826 av_freep(&s->dc_val_base);
827 av_freep(&s->ac_val_base);
828 av_freep(&s->coded_block_base);
6000abfa 829 av_freep(&s->mbintra_table);
7f2fe444
MN
830 av_freep(&s->cbp_table);
831 av_freep(&s->pred_dir_table);
7f2fe444 832
6000abfa 833 av_freep(&s->mbskip_table);
f943e138 834 av_freep(&s->prev_pict_types);
6000abfa 835 av_freep(&s->bitstream_buffer);
3aa102be 836 av_freep(&s->avctx->stats_out);
6b460aa3 837 av_freep(&s->ac_stats);
4d2858de 838 av_freep(&s->error_status_table);
7bc9090a 839 av_freep(&s->mb_index2xy);
158c7f05 840 av_freep(&s->lambda_table);
7e4995c3
MN
841 av_freep(&s->q_intra_matrix);
842 av_freep(&s->q_inter_matrix);
642ccefb
MN
843 av_freep(&s->q_intra_matrix16);
844 av_freep(&s->q_inter_matrix16);
9d9e3172
MN
845 av_freep(&s->input_picture);
846 av_freep(&s->reordered_input_picture);
821cb11f 847 av_freep(&s->dct_offset);
1e491e29 848
9b4b6e09
MN
849 if(s->picture){
850 for(i=0; i<MAX_PICTURE_COUNT; i++){
851 free_picture(s, &s->picture[i]);
852 }
de6d9b64 853 }
b465449e 854 av_freep(&s->picture);
de6d9b64 855 s->context_initialized = 0;
431f2172
MN
856 s->last_picture_ptr=
857 s->next_picture_ptr=
858 s->current_picture_ptr= NULL;
8100cab9 859
0c9bbaec 860 for(i=0; i<3; i++)
8100cab9 861 av_freep(&s->visualization_buffer[i]);
de6d9b64
FB
862}
863
7604246d
WH
864#ifdef CONFIG_ENCODERS
865
de6d9b64
FB
866/* init video encoder */
867int MPV_encode_init(AVCodecContext *avctx)
868{
869 MpegEncContext *s = avctx->priv_data;
22ddd60b 870 int i, dummy;
b1e6b355 871 int chroma_h_shift, chroma_v_shift;
3edcacde
MN
872
873 MPV_encode_defaults(s);
bc657ac3 874
36b58e85
RS
875 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
876
de6d9b64 877 s->bit_rate = avctx->bit_rate;
de6d9b64
FB
878 s->width = avctx->width;
879 s->height = avctx->height;
7f2fe444 880 if(avctx->gop_size > 600){
9b879566 881 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
7f2fe444
MN
882 avctx->gop_size=600;
883 }
de6d9b64 884 s->gop_size = avctx->gop_size;
477c35a9 885 s->avctx = avctx;
ba6802de 886 s->flags= avctx->flags;
303e50e6 887 s->flags2= avctx->flags2;
9dbcbd92 888 s->max_b_frames= avctx->max_b_frames;
d7e9533a 889 s->codec_id= avctx->codec->id;
7f2fe444
MN
890 s->luma_elim_threshold = avctx->luma_elim_threshold;
891 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
892 s->strict_std_compliance= avctx->strict_std_compliance;
893 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
1457ab52 894 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
87f8cab4 895 s->mpeg_quant= avctx->mpeg_quant;
ba58dabc 896 s->rtp_mode= !!avctx->rtp_payload_size;
bf266e19 897 s->intra_dc_precision= avctx->intra_dc_precision;
e4eadb4b 898
de6d9b64
FB
899 if (s->gop_size <= 1) {
900 s->intra_only = 1;
901 s->gop_size = 12;
902 } else {
903 s->intra_only = 0;
904 }
5e746b99 905
1457ab52 906 s->me_method = avctx->me_method;
5e746b99 907
e4986da9 908 /* Fixed QSCALE */
bb198e19 909 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
37fbfd0a 910
c5d309f2 911 s->adaptive_quant= ( s->avctx->lumi_masking
5e746b99 912 || s->avctx->dark_masking
c5d309f2
MN
913 || s->avctx->temporal_cplx_masking
914 || s->avctx->spatial_cplx_masking
1f26c6f3
MN
915 || s->avctx->p_masking
916 || (s->flags&CODEC_FLAG_QP_RD))
c5d309f2 917 && !s->fixed_qscale;
fcb48651 918
bb198e19
MN
919 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
920 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
921 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
5e746b99 922
273977d8
MN
923 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
924 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
925 return -1;
926 }
927
928 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
929 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
b73afeac
MN
930 }
931
932 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
933 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
934 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
273977d8 935
b73afeac
MN
936 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");
937 }
938
f7190f73 939 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
747a0554 940 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
9b879566 941 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
9acbbd16
MN
942 return -1;
943 }
273977d8 944
f7190f73
MN
945 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
946 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
947 return -1;
948 }
949
332f9ac4
MN
950 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
951 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
952 return -1;
953 }
954
9acbbd16 955 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
9b879566 956 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
9acbbd16
MN
957 return -1;
958 }
959
960 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
9b879566 961 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
9acbbd16
MN
962 return -1;
963 }
964
029911d1 965 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
9b879566 966 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
9acbbd16
MN
967 return -1;
968 }
1671083f
MN
969
970 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
971 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
972 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
973 return -1;
974 }
975
9acbbd16 976 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
9b879566 977 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
9acbbd16
MN
978 return -1;
979 }
e4eadb4b 980
f2f6134b 981 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
9b879566 982 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
f2f6134b
MN
983 return -1;
984 }
985
dd3e415e
MN
986 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
987 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
988 return -1;
989 }
990
303e50e6
MN
991 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
992 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
993 return -1;
994 }
9c3d33d6
MN
995
996 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
997 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
998 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
999 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1000 return -1;
1001 }
1002
1003 if(s->avctx->thread_count > 1)
1004 s->rtp_mode= 1;
11a8a71d
MN
1005
1006 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1007 if(i > 1){
1008 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1009 avctx->frame_rate /= i;
1010 avctx->frame_rate_base /= i;
1011// return -1;
1012 }
303e50e6 1013
1984f635
MN
1014 if(s->codec_id==CODEC_ID_MJPEG){
1015 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1016 s->inter_quant_bias= 0;
029911d1 1017 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1984f635
MN
1018 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1019 s->inter_quant_bias= 0;
1020 }else{
1021 s->intra_quant_bias=0;
1022 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1023 }
1024
1025 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1026 s->intra_quant_bias= avctx->intra_quant_bias;
1027 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1028 s->inter_quant_bias= avctx->inter_quant_bias;
b1e6b355
MN
1029
1030 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1031
22ddd60b
MN
1032 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1033 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1034
de6d9b64
FB
1035 switch(avctx->codec->id) {
1036 case CODEC_ID_MPEG1VIDEO:
1037 s->out_format = FMT_MPEG1;
14bea432
MN
1038 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1039 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1040 break;
029911d1
MN
1041 case CODEC_ID_MPEG2VIDEO:
1042 s->out_format = FMT_MPEG1;
1043 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1044 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
ba58dabc 1045 s->rtp_mode= 1;
029911d1 1046 break;
b1e6b355 1047 case CODEC_ID_LJPEG:
de6d9b64
FB
1048 case CODEC_ID_MJPEG:
1049 s->out_format = FMT_MJPEG;
1050 s->intra_only = 1; /* force intra only for jpeg */
37fbfd0a 1051 s->mjpeg_write_tables = 1; /* write all tables */
a69b930c 1052 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
b1e6b355
MN
1053 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1054 s->mjpeg_vsample[1] = 1;
37fbfd0a 1055 s->mjpeg_vsample[2] = 1;
b1e6b355 1056 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
37fbfd0a
J
1057 s->mjpeg_hsample[1] = 1;
1058 s->mjpeg_hsample[2] = 1;
de6d9b64
FB
1059 if (mjpeg_init(s) < 0)
1060 return -1;
1ff662cc 1061 avctx->delay=0;
4e00e76b 1062 s->low_delay=1;
de6d9b64 1063 break;
1d0d55da 1064#ifdef CONFIG_RISKY
de6d9b64 1065 case CODEC_ID_H263:
37fbfd0a 1066 if (h263_get_picture_format(s->width, s->height) == 7) {
9b879566 1067 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
de6d9b64 1068 return -1;
37fbfd0a 1069 }
de6d9b64 1070 s->out_format = FMT_H263;
332f9ac4 1071 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1ff662cc 1072 avctx->delay=0;
4e00e76b 1073 s->low_delay=1;
de6d9b64
FB
1074 break;
1075 case CODEC_ID_H263P:
1076 s->out_format = FMT_H263;
1077 s->h263_plus = 1;
21e59552 1078 /* Fx */
332f9ac4 1079 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
21e59552 1080 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
332f9ac4 1081 s->modified_quant= s->h263_aic;
dba019da 1082 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
332f9ac4
MN
1083 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1084 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1085 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
ba58dabc 1086 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
332f9ac4 1087
21e59552 1088 /* /Fx */
544286b3 1089 /* These are just to be sure */
1ff662cc 1090 avctx->delay=0;
4e00e76b 1091 s->low_delay=1;
de6d9b64 1092 break;
d4f5d74a
GM
1093 case CODEC_ID_FLV1:
1094 s->out_format = FMT_H263;
1095 s->h263_flv = 2; /* format = 1; 11-bit codes */
1096 s->unrestricted_mv = 1;
1097 s->rtp_mode=0; /* don't allow GOB */
1098 avctx->delay=0;
1099 s->low_delay=1;
1100 break;
de6d9b64
FB
1101 case CODEC_ID_RV10:
1102 s->out_format = FMT_H263;
1ff662cc 1103 avctx->delay=0;
4e00e76b 1104 s->low_delay=1;
de6d9b64 1105 break;
58f26ba9 1106 case CODEC_ID_MPEG4:
de6d9b64
FB
1107 s->out_format = FMT_H263;
1108 s->h263_pred = 1;
1109 s->unrestricted_mv = 1;
4e00e76b 1110 s->low_delay= s->max_b_frames ? 0 : 1;
4d2858de 1111 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1112 break;
84afee34 1113 case CODEC_ID_MSMPEG4V1:
de6d9b64
FB
1114 s->out_format = FMT_H263;
1115 s->h263_msmpeg4 = 1;
1116 s->h263_pred = 1;
1117 s->unrestricted_mv = 1;
84afee34 1118 s->msmpeg4_version= 1;
1ff662cc 1119 avctx->delay=0;
4e00e76b 1120 s->low_delay=1;
84afee34
MN
1121 break;
1122 case CODEC_ID_MSMPEG4V2:
1123 s->out_format = FMT_H263;
1124 s->h263_msmpeg4 = 1;
1125 s->h263_pred = 1;
1126 s->unrestricted_mv = 1;
1127 s->msmpeg4_version= 2;
1ff662cc 1128 avctx->delay=0;
4e00e76b 1129 s->low_delay=1;
84afee34
MN
1130 break;
1131 case CODEC_ID_MSMPEG4V3:
1132 s->out_format = FMT_H263;
1133 s->h263_msmpeg4 = 1;
1134 s->h263_pred = 1;
1135 s->unrestricted_mv = 1;
1136 s->msmpeg4_version= 3;
1f9aea9b 1137 s->flipflop_rounding=1;
1ff662cc 1138 avctx->delay=0;
4e00e76b 1139 s->low_delay=1;
de6d9b64 1140 break;
f5957f3f
MN
1141 case CODEC_ID_WMV1:
1142 s->out_format = FMT_H263;
1143 s->h263_msmpeg4 = 1;
1144 s->h263_pred = 1;
1145 s->unrestricted_mv = 1;
1146 s->msmpeg4_version= 4;
1f9aea9b 1147 s->flipflop_rounding=1;
f5957f3f 1148 avctx->delay=0;
4e00e76b 1149 s->low_delay=1;
f5957f3f
MN
1150 break;
1151 case CODEC_ID_WMV2:
1152 s->out_format = FMT_H263;
1153 s->h263_msmpeg4 = 1;
1154 s->h263_pred = 1;
1155 s->unrestricted_mv = 1;
1156 s->msmpeg4_version= 5;
1f9aea9b 1157 s->flipflop_rounding=1;
f5957f3f 1158 avctx->delay=0;
4e00e76b 1159 s->low_delay=1;
f5957f3f 1160 break;
1d0d55da 1161#endif
de6d9b64
FB
1162 default:
1163 return -1;
1164 }
57518155
MN
1165
1166 avctx->has_b_frames= !s->low_delay;
2c492e94 1167
3bb4e23a
FB
1168 s->encoding = 1;
1169
de6d9b64
FB
1170 /* init */
1171 if (MPV_common_init(s) < 0)
1172 return -1;
dd5e90cd
MN
1173
1174 if(s->modified_quant)
1175 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1176 s->progressive_frame=
bb198e19 1177 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
9c3d33d6 1178 s->quant_precision=5;
de6d9b64 1179
622348f9
MN
1180 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1181
bbed9259 1182#ifdef CONFIG_ENCODERS
1d0d55da 1183#ifdef CONFIG_RISKY
2ad1516a
MN
1184 if (s->out_format == FMT_H263)
1185 h263_encode_init(s);
2ad1516a
MN
1186 if(s->msmpeg4_version)
1187 ff_msmpeg4_encode_init(s);
bbed9259 1188#endif
1d0d55da
MN
1189 if (s->out_format == FMT_MPEG1)
1190 ff_mpeg1_encode_init(s);
1191#endif
2ad1516a 1192
3edcacde 1193 /* init q matrix */
519c2b6d 1194 for(i=0;i<64;i++) {
b0368839 1195 int j= s->dsp.idct_permutation[i];
1d0d55da 1196#ifdef CONFIG_RISKY
87f8cab4 1197 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
2ad1516a
MN
1198 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1199 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
87f8cab4 1200 }else if(s->out_format == FMT_H263){
2ad1516a
MN
1201 s->intra_matrix[j] =
1202 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1d0d55da
MN
1203 }else
1204#endif
029911d1 1205 { /* mpeg1/2 */
2ad1516a
MN
1206 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1207 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
87f8cab4 1208 }
d6eb3c50
MN
1209 if(s->avctx->intra_matrix)
1210 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1211 if(s->avctx->inter_matrix)
1212 s->inter_matrix[j] = s->avctx->inter_matrix[i];
d7e9533a
MN
1213 }
1214
1215 /* precompute matrix */
ef5b1b5a 1216 /* for mjpeg, we do include qscale in the matrix */
d7e9533a 1217 if (s->out_format != FMT_MJPEG) {
6b56c616 1218 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
cc7ac888 1219 s->intra_matrix, s->intra_quant_bias, 1, 31);
6b56c616 1220 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
cc7ac888 1221 s->inter_matrix, s->inter_quant_bias, 1, 31);
519c2b6d
FB
1222 }
1223
8b4c7dbc
MN
1224 if(ff_rate_control_init(s) < 0)
1225 return -1;
3edcacde 1226
de6d9b64
FB
1227 return 0;
1228}
1229
1230int MPV_encode_end(AVCodecContext *avctx)
1231{
1232 MpegEncContext *s = avctx->priv_data;
1233
1234#ifdef STATS
1235 print_stats();
1236#endif
8b4c7dbc
MN
1237
1238 ff_rate_control_uninit(s);
1239
de6d9b64
FB
1240 MPV_common_end(s);
1241 if (s->out_format == FMT_MJPEG)
1242 mjpeg_close(s);
541ae140 1243
22ddd60b 1244 av_freep(&avctx->extradata);
37fbfd0a 1245
de6d9b64
FB
1246 return 0;
1247}
1248
7604246d
WH
1249#endif //CONFIG_ENCODERS
1250
1d0d55da
MN
1251void init_rl(RLTable *rl)
1252{
0c1a9eda
ZK
1253 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1254 uint8_t index_run[MAX_RUN+1];
1d0d55da
MN
1255 int last, run, level, start, end, i;
1256
1257 /* compute max_level[], max_run[] and index_run[] */
1258 for(last=0;last<2;last++) {
1259 if (last == 0) {
1260 start = 0;
1261 end = rl->last;
1262 } else {
1263 start = rl->last;
1264 end = rl->n;
1265 }
1266
1267 memset(max_level, 0, MAX_RUN + 1);
1268 memset(max_run, 0, MAX_LEVEL + 1);
1269 memset(index_run, rl->n, MAX_RUN + 1);
1270 for(i=start;i<end;i++) {
1271 run = rl->table_run[i];
1272 level = rl->table_level[i];
1273 if (index_run[run] == rl->n)
1274 index_run[run] = i;
1275 if (level > max_level[run])
1276 max_level[run] = level;
1277 if (run > max_run[level])
1278 max_run[level] = run;
1279 }
1280 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1281 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1282 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1283 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1284 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1285 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1286 }
1287}
1288
de6d9b64 1289/* draw the edges of width 'w' of an image of size width, height */
fd7db0fd 1290//FIXME check that this is ok for mpeg4 interlaced
0c1a9eda 1291static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
de6d9b64 1292{
0c1a9eda 1293 uint8_t *ptr, *last_line;
de6d9b64
FB
1294 int i;
1295
1296 last_line = buf + (height - 1) * wrap;
1297 for(i=0;i<w;i++) {
1298 /* top and bottom */
1299 memcpy(buf - (i + 1) * wrap, buf, width);
1300 memcpy(last_line + (i + 1) * wrap, last_line, width);
1301 }
1302 /* left and right */
1303 ptr = buf;
1304 for(i=0;i<height;i++) {
1305 memset(ptr - w, ptr[0], w);
1306 memset(ptr + width, ptr[width-1], w);
1307 ptr += wrap;
1308 }
1309 /* corners */
1310 for(i=0;i<w;i++) {
1311 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1312 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1313 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1314 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1315 }
1316}
1317
5f194811 1318int ff_find_unused_picture(MpegEncContext *s, int shared){
4e00e76b
MN
1319 int i;
1320
1321 if(shared){
1322 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1323 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
4e00e76b
MN
1324 }
1325 }else{
1326 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1327 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
4e00e76b
MN
1328 }
1329 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1330 if(s->picture[i].data[0]==NULL) return i;
4e00e76b
MN
1331 }
1332 }
1333
5f194811
MN
1334 assert(0);
1335 return -1;
4e00e76b
MN
1336}
1337
821cb11f
MN
1338static void update_noise_reduction(MpegEncContext *s){
1339 int intra, i;
1340
1341 for(intra=0; intra<2; intra++){
1342 if(s->dct_count[intra] > (1<<16)){
1343 for(i=0; i<64; i++){
1344 s->dct_error_sum[intra][i] >>=1;
1345 }
1346 s->dct_count[intra] >>= 1;
1347 }
1348
1349 for(i=0; i<64; i++){
1350 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);
1351 }
1352 }
1353}
1354
5f194811
MN
1355/**
1356 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1357 */
d6db1c9c 1358int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
de6d9b64 1359{
4e00e76b 1360 int i;
492cd3a9 1361 AVFrame *pic;
425dddb7 1362 s->mb_skiped = 0;
0da71265 1363
8b82a956 1364 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
e20c4069 1365
1e491e29 1366 /* mark&release old frames */
14e2a940 1367 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 1368 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1e491e29
MN
1369
1370 /* release forgotten pictures */
1371 /* if(mpeg124/h263) */
1372 if(!s->encoding){
1373 for(i=0; i<MAX_PICTURE_COUNT; i++){
b536d0aa 1374 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
9b879566 1375 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
492cd3a9 1376 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1e491e29
MN
1377 }
1378 }
d6db1c9c 1379 }
93a21abd 1380 }
aa388dba
MN
1381alloc:
1382 if(!s->encoding){
e20c4069
MN
1383 /* release non refernce frames */
1384 for(i=0; i<MAX_PICTURE_COUNT; i++){
1385 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1386 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1387 }
1388 }
1389
5f194811
MN
1390 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1391 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1392 else{
1393 i= ff_find_unused_picture(s, 0);
1394 pic= (AVFrame*)&s->picture[i];
1395 }
1396
14e2a940 1397 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
b536d0aa 1398
1031fabd 1399 pic->coded_picture_number= s->coded_picture_number++;
1e491e29 1400
f23a68df
IK
1401 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1402 return -1;
93a21abd 1403
5f194811 1404 s->current_picture_ptr= (Picture*)pic;
c70f1716 1405 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
2be9f03a 1406 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1e491e29 1407 }
b7adc711 1408
9f2e61b6 1409 s->current_picture_ptr->pict_type= s->pict_type;
158c7f05
MN
1410// if(s->flags && CODEC_FLAG_QSCALE)
1411 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
7bc9090a 1412 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
9f2e61b6 1413
6571e41d 1414 copy_picture(&s->current_picture, s->current_picture_ptr);
9f2e61b6 1415
8b82a956 1416 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1e491e29 1417 if (s->pict_type != B_TYPE) {
b536d0aa 1418 s->last_picture_ptr= s->next_picture_ptr;
14e2a940
MN
1419 if(!s->dropable)
1420 s->next_picture_ptr= s->current_picture_ptr;
de6d9b64 1421 }
14e2a940
MN
1422/* 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,
1423 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1424 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1425 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1426 s->pict_type, s->dropable);*/
d90cf87b 1427
6571e41d
MN
1428 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1429 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
aa388dba 1430
6571e41d 1431 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
9b879566 1432 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
ffba1dc0
MN
1433 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1434 goto alloc;
1435 }
1436
1437 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1438
b536d0aa
MN
1439 if(s->picture_structure!=PICT_FRAME){
1440 int i;
1441 for(i=0; i<4; i++){
1442 if(s->picture_structure == PICT_BOTTOM_FIELD){
1443 s->current_picture.data[i] += s->current_picture.linesize[i];
1444 }
1445 s->current_picture.linesize[i] *= 2;
1446 s->last_picture.linesize[i] *=2;
1447 s->next_picture.linesize[i] *=2;
1448 }
1449 }
0da71265 1450 }
1e491e29 1451
aa388dba
MN
1452 s->hurry_up= s->avctx->hurry_up;
1453 s->error_resilience= avctx->error_resilience;
1454
d930ef19
MN
1455 /* set dequantizer, we cant do it during init as it might change for mpeg4
1456 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
d50635cd
MN
1457 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1458 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1459 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1460 }else if(s->out_format == FMT_H263){
1461 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1462 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
c6148de2
MN
1463 }else if(s->out_format == FMT_H261){
1464 s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1465 s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
d50635cd
MN
1466 }else{
1467 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1468 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1469 }
d6db1c9c 1470
821cb11f
MN
1471 if(s->dct_error_sum){
1472 assert(s->avctx->noise_reduction && s->encoding);
1473
1474 update_noise_reduction(s);
1475 }
1476
2e7b4c84
IK
1477#ifdef HAVE_XVMC
1478 if(s->avctx->xvmc_acceleration)
1479 return XVMC_field_start(s, avctx);
1480#endif
d6db1c9c 1481 return 0;
de6d9b64 1482}
21af69f7 1483
de6d9b64
FB
1484/* generic function for encode/decode called after a frame has been coded/decoded */
1485void MPV_frame_end(MpegEncContext *s)
1486{
1e491e29 1487 int i;
de6d9b64 1488 /* draw edge for correct motion prediction if outside */
2e7b4c84
IK
1489#ifdef HAVE_XVMC
1490//just to make sure that all data is rendered.
1491 if(s->avctx->xvmc_acceleration){
1492 XVMC_field_end(s);
1493 }else
1494#endif
a573cc27 1495 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1e491e29
MN
1496 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1497 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1498 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
de6d9b64 1499 }
5975626d 1500 emms_c();
8b4c7dbc 1501
3aa102be 1502 s->last_pict_type = s->pict_type;
8b4c7dbc
MN
1503 if(s->pict_type!=B_TYPE){
1504 s->last_non_b_pict_type= s->pict_type;
8b4c7dbc 1505 }
b536d0aa
MN
1506#if 0
1507 /* copy back current_picture variables */
1e491e29
MN
1508 for(i=0; i<MAX_PICTURE_COUNT; i++){
1509 if(s->picture[i].data[0] == s->current_picture.data[0]){
1510 s->picture[i]= s->current_picture;
1511 break;
1512 }
1513 }
1514 assert(i<MAX_PICTURE_COUNT);
b536d0aa 1515#endif
1e491e29 1516
e20c4069
MN
1517 if(s->encoding){
1518 /* release non refernce frames */
1519 for(i=0; i<MAX_PICTURE_COUNT; i++){
1520 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1521 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1522 }
1523 }
1e491e29 1524 }
b536d0aa
MN
1525 // clear copies, to avoid confusion
1526#if 0
1527 memset(&s->last_picture, 0, sizeof(Picture));
1528 memset(&s->next_picture, 0, sizeof(Picture));
1529 memset(&s->current_picture, 0, sizeof(Picture));
1530#endif
de6d9b64
FB
1531}
1532
7bc9090a 1533/**
db6e7795
MN
1534 * draws an line from (ex, ey) -> (sx, sy).
1535 * @param w width of the image
1536 * @param h height of the image
1537 * @param stride stride/linesize of the image
1538 * @param color color of the arrow
1539 */
1540static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
8100cab9 1541 int t, x, y, fr, f;
db6e7795
MN
1542
1543 sx= clip(sx, 0, w-1);
1544 sy= clip(sy, 0, h-1);
1545 ex= clip(ex, 0, w-1);
1546 ey= clip(ey, 0, h-1);
1547
1548 buf[sy*stride + sx]+= color;
1549
1550 if(ABS(ex - sx) > ABS(ey - sy)){
1551 if(sx > ex){
1552 t=sx; sx=ex; ex=t;
1553 t=sy; sy=ey; ey=t;
1554 }
1555 buf+= sx + sy*stride;
1556 ex-= sx;
1557 f= ((ey-sy)<<16)/ex;
1558 for(x= 0; x <= ex; x++){
8100cab9
MN
1559 y = (x*f)>>16;
1560 fr= (x*f)&0xFFFF;
1561 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1562 buf[(y+1)*stride + x]+= (color* fr )>>16;
db6e7795
MN
1563 }
1564 }else{
1565 if(sy > ey){
1566 t=sx; sx=ex; ex=t;
1567 t=sy; sy=ey; ey=t;
1568 }
1569 buf+= sx + sy*stride;
1570 ey-= sy;
1571 if(ey) f= ((ex-sx)<<16)/ey;
1572 else f= 0;
1573 for(y= 0; y <= ey; y++){
8100cab9
MN
1574 x = (y*f)>>16;
1575 fr= (y*f)&0xFFFF;
1576 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1577 buf[y*stride + x+1]+= (color* fr )>>16;;
db6e7795
MN
1578 }
1579 }
1580}
1581
1582/**
1583 * draws an arrow from (ex, ey) -> (sx, sy).
1584 * @param w width of the image
1585 * @param h height of the image
1586 * @param stride stride/linesize of the image
1587 * @param color color of the arrow
1588 */
1589static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1590 int dx,dy;
1591
1592 sx= clip(sx, -100, w+100);
1593 sy= clip(sy, -100, h+100);
1594 ex= clip(ex, -100, w+100);
1595 ey= clip(ey, -100, h+100);
1596
1597 dx= ex - sx;
1598 dy= ey - sy;
1599
1600 if(dx*dx + dy*dy > 3*3){
1601 int rx= dx + dy;
1602 int ry= -dx + dy;
1603 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1604
1605 //FIXME subpixel accuracy
1606 rx= ROUNDED_DIV(rx*3<<4, length);
1607 ry= ROUNDED_DIV(ry*3<<4, length);
1608
1609 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1610 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1611 }
1612 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1613}
1614
1615/**
7bc9090a
MN
1616 * prints debuging info for the given picture.
1617 */
0c9bbaec 1618void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
7bc9090a
MN
1619
1620 if(!pict || !pict->mb_type) return;
1621
1622 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1623 int x,y;
0c9bbaec
WH
1624
1625 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1626 switch (pict->pict_type) {
1627 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1628 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1629 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1630 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1631 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1632 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1633 }
7bc9090a
MN
1634 for(y=0; y<s->mb_height; y++){
1635 for(x=0; x<s->mb_width; x++){
1636 if(s->avctx->debug&FF_DEBUG_SKIP){
1637 int count= s->mbskip_table[x + y*s->mb_stride];
1638 if(count>9) count=9;
9b879566 1639 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
7bc9090a
MN
1640 }
1641 if(s->avctx->debug&FF_DEBUG_QP){
9b879566 1642 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
7bc9090a
MN
1643 }
1644 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1645 int mb_type= pict->mb_type[x + y*s->mb_stride];
7bc9090a
MN
1646 //Type & MV direction
1647 if(IS_PCM(mb_type))
9b879566 1648 av_log(s->avctx, AV_LOG_DEBUG, "P");
7bc9090a 1649 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
9b879566 1650 av_log(s->avctx, AV_LOG_DEBUG, "A");
7bc9090a 1651 else if(IS_INTRA4x4(mb_type))
9b879566 1652 av_log(s->avctx, AV_LOG_DEBUG, "i");
7bc9090a 1653 else if(IS_INTRA16x16(mb_type))
9b879566 1654 av_log(s->avctx, AV_LOG_DEBUG, "I");
7bc9090a 1655 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
9b879566 1656 av_log(s->avctx, AV_LOG_DEBUG, "d");
7bc9090a 1657 else if(IS_DIRECT(mb_type))
9b879566 1658 av_log(s->avctx, AV_LOG_DEBUG, "D");
7bc9090a 1659 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
9b879566 1660 av_log(s->avctx, AV_LOG_DEBUG, "g");
7bc9090a 1661 else if(IS_GMC(mb_type))
9b879566 1662 av_log(s->avctx, AV_LOG_DEBUG, "G");
7bc9090a 1663 else if(IS_SKIP(mb_type))
9b879566 1664 av_log(s->avctx, AV_LOG_DEBUG, "S");
7bc9090a 1665 else if(!USES_LIST(mb_type, 1))
9b879566 1666 av_log(s->avctx, AV_LOG_DEBUG, ">");
7bc9090a 1667 else if(!USES_LIST(mb_type, 0))
9b879566 1668 av_log(s->avctx, AV_LOG_DEBUG, "<");
7bc9090a
MN
1669 else{
1670 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
9b879566 1671 av_log(s->avctx, AV_LOG_DEBUG, "X");
7bc9090a
MN
1672 }
1673
1674 //segmentation
1675 if(IS_8X8(mb_type))
9b879566 1676 av_log(s->avctx, AV_LOG_DEBUG, "+");
7bc9090a 1677 else if(IS_16X8(mb_type))
9b879566 1678 av_log(s->avctx, AV_LOG_DEBUG, "-");
7bc9090a 1679 else if(IS_8X16(mb_type))
9b879566 1680