CONFIG_XVID --> CONFIG_LIBXVID
[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 *
b78e7197
DB
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
ff4ec49e
FB
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
b78e7197 11 * version 2.1 of the License, or (at your option) any later version.
de6d9b64 12 *
b78e7197 13 * FFmpeg is distributed in the hope that it will be useful,
de6d9b64 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
de6d9b64 17 *
ff4ec49e 18 * You should have received a copy of the GNU Lesser General Public
b78e7197 19 * License along with FFmpeg; if not, write to the Free Software
5509bffa 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
cf8039b2 21 *
9dbf1ddd 22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
de6d9b64 23 */
115329f1 24
983e3246
MN
25/**
26 * @file mpegvideo.c
27 * The simplest mpeg encoder (well, it was the simplest!).
115329f1
DB
28 */
29
de6d9b64
FB
30#include "avcodec.h"
31#include "dsputil.h"
32#include "mpegvideo.h"
d9c9259f 33#include "mjpegenc.h"
15025553 34#include "msmpeg4.h"
65e4c8c9 35#include "faandct.h"
e96682e6 36#include <limits.h>
de6d9b64 37
e4eadb4b
MN
38//#undef NDEBUG
39//#include <assert.h>
2ad1516a 40
7604246d 41#ifdef CONFIG_ENCODERS
4156a436 42static int encode_picture(MpegEncContext *s, int picture_number);
7604246d 43#endif //CONFIG_ENCODERS
115329f1 44static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
21af69f7 45 DCTELEM *block, int n, int qscale);
115329f1 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);
e27b6e62
MN
50static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
d50635cd
MN
52static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
115329f1 54static void dct_unquantize_h263_intra_c(MpegEncContext *s,
d50635cd 55 DCTELEM *block, int n, int qscale);
115329f1 56static void dct_unquantize_h263_inter_c(MpegEncContext *s,
21af69f7 57 DCTELEM *block, int n, int qscale);
0c1a9eda 58static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
7604246d 59#ifdef CONFIG_ENCODERS
d7e9533a 60static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
477ab036 61static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
77ea0d4b 62static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
7d1c3fc1 63static int sse_mb(MpegEncContext *s);
783df5f3 64static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
7604246d 65#endif //CONFIG_ENCODERS
3d9fccbf 66
2e7b4c84
IK
67#ifdef HAVE_XVMC
68extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
69extern void XVMC_field_end(MpegEncContext *s);
a579db0c 70extern void XVMC_decode_mb(MpegEncContext *s);
2e7b4c84
IK
71#endif
72
0c1a9eda 73void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
3d9fccbf 74
de6d9b64
FB
75
76/* enable all paranoid tests for rounding, overflows, etc... */
77//#define PARANOID
78
79//#define DEBUG
80
101bea5f 81
8c71c5e4 82#ifdef CONFIG_ENCODERS
eb4b3dd3 83static const uint16_t aanscales[64] = {
de6d9b64
FB
84 /* precomputed values scaled up by 14 bits */
85 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
86 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
87 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
88 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
1457ab52
MN
91 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
92 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
de6d9b64 93};
8c71c5e4 94#endif //CONFIG_ENCODERS
de6d9b64 95
eb4b3dd3 96static const uint8_t h263_chroma_roundtab[16] = {
67725183 97// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
de6d9b64
FB
98 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
99};
100
332f9ac4
MN
101static const uint8_t ff_default_chroma_qscale_table[32]={
102// 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
103 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
104};
105
7604246d 106#ifdef CONFIG_ENCODERS
5ac09151 107static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
0c1a9eda 108static uint8_t default_fcode_tab[MAX_MV*2+1];
45870f57 109
a33c7159
MN
110enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
111
6b56c616 112static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
732ce18e 113 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
de6d9b64 114{
d7e9533a 115 int qscale;
732ce18e 116 int shift=0;
d7e9533a 117
cc7ac888 118 for(qscale=qmin; qscale<=qmax; qscale++){
d7e9533a 119 int i;
115329f1 120 if (dsp->fdct == ff_jpeg_fdct_islow
b4c3816c 121#ifdef FAAN_POSTSCALE
6b56c616 122 || dsp->fdct == ff_faandct
b4c3816c
MN
123#endif
124 ) {
28db7fce 125 for(i=0;i<64;i++) {
6b56c616 126 const int j= dsp->idct_permutation[i];
28db7fce
MN
127 /* 16 <= qscale * quant_matrix[i] <= 7905 */
128 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
129 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
130 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
115329f1 131
8da9266c 132 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
28db7fce
MN
133 (qscale * quant_matrix[j]));
134 }
6b56c616 135 } else if (dsp->fdct == fdct_ifast
b4c3816c 136#ifndef FAAN_POSTSCALE
6b56c616 137 || dsp->fdct == ff_faandct
b4c3816c
MN
138#endif
139 ) {
d7e9533a 140 for(i=0;i<64;i++) {
6b56c616 141 const int j= dsp->idct_permutation[i];
d7e9533a
MN
142 /* 16 <= qscale * quant_matrix[i] <= 7905 */
143 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
144 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
145 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
115329f1 146
8da9266c 147 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
d7e9533a
MN
148 (aanscales[i] * qscale * quant_matrix[j]));
149 }
150 } else {
151 for(i=0;i<64;i++) {
6b56c616 152 const int j= dsp->idct_permutation[i];
d7e9533a
MN
153 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
154 So 16 <= qscale * quant_matrix[i] <= 7905
155 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
156 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
157 */
8da9266c 158 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
477ab036 159// qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
642ccefb 160 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
d7e9533a 161
642ccefb
MN
162 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
163 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
d7e9533a 164 }
de6d9b64 165 }
115329f1 166
732ce18e 167 for(i=intra; i<64; i++){
3c9ec07e
MN
168 int64_t max= 8191;
169 if (dsp->fdct == fdct_ifast
170#ifndef FAAN_POSTSCALE
171 || dsp->fdct == ff_faandct
172#endif
173 ) {
174 max= (8191LL*aanscales[i]) >> 14;
175 }
115329f1 176 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
732ce18e
MN
177 shift++;
178 }
179 }
180 }
181 if(shift){
1d726a59 182 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
de6d9b64
FB
183 }
184}
158c7f05
MN
185
186static inline void update_qscale(MpegEncContext *s){
187 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
f66e4f5f 188 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
115329f1 189
158c7f05
MN
190 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
191}
7604246d
WH
192#endif //CONFIG_ENCODERS
193
3d2e8cce 194void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
2ad1516a
MN
195 int i;
196 int end;
115329f1 197
7801d21d 198 st->scantable= src_scantable;
2ad1516a
MN
199
200 for(i=0; i<64; i++){
201 int j;
202 j = src_scantable[i];
3d2e8cce 203 st->permutated[i] = permutation[j];
05c4072b
MN
204#ifdef ARCH_POWERPC
205 st->inverse[j] = i;
206#endif
2ad1516a 207 }
115329f1 208
2ad1516a
MN
209 end=-1;
210 for(i=0; i<64; i++){
211 int j;
212 j = st->permutated[i];
213 if(j>end) end=j;
214 st->raster_end[i]= end;
215 }
216}
217
764ef400 218#ifdef CONFIG_ENCODERS
191e8ca7 219void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
d6eb3c50
MN
220 int i;
221
222 if(matrix){
223 put_bits(pb, 1, 1);
224 for(i=0;i<64;i++) {
225 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
226 }
227 }else
228 put_bits(pb, 1, 0);
229}
764ef400 230#endif //CONFIG_ENCODERS
d6eb3c50 231
82fcbc14
MN
232const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
233 int i;
234
8cb90572
MN
235 assert(p<=end);
236 if(p>=end)
237 return end;
238
82fcbc14
MN
239 for(i=0; i<3; i++){
240 uint32_t tmp= *state << 8;
241 *state= tmp + *(p++);
242 if(tmp == 0x100 || p==end)
243 return p;
244 }
82fcbc14
MN
245
246 while(p<end){
809b2a30
MN
247 if (p[-1] > 1 ) p+= 3;
248 else if(p[-2] ) p+= 2;
249 else if(p[-3]|(p[-1]-1)) p++;
82fcbc14
MN
250 else{
251 p++;
252 break;
253 }
254 }
255
809b2a30 256 p= FFMIN(p, end)-4;
82fcbc14
MN
257 *state= be2me_32(unaligned32(p));
258
259 return p+4;
260}
261
defdfc9a
AB
262/* init common dct for both encoder and decoder */
263int DCT_common_init(MpegEncContext *s)
de6d9b64 264{
d50635cd
MN
265 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
266 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
267 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
268 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
269 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
e27b6e62
MN
270 if(s->flags & CODEC_FLAG_BITEXACT)
271 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
d50635cd 272 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
b0368839 273
ad0f6c1f 274#if defined(HAVE_MMX)
e4eadb4b 275 MPV_common_init_mmx(s);
ad0f6c1f 276#elif defined(ARCH_ALPHA)
e0580f8c 277 MPV_common_init_axp(s);
ad0f6c1f 278#elif defined(HAVE_MLIB)
c7e07931 279 MPV_common_init_mlib(s);
ad0f6c1f 280#elif defined(HAVE_MMI)
5917d17c 281 MPV_common_init_mmi(s);
ad0f6c1f 282#elif defined(ARCH_ARMV4L)
83f238cb 283 MPV_common_init_armv4l(s);
ad0f6c1f 284#elif defined(ARCH_POWERPC)
05c4072b 285 MPV_common_init_ppc(s);
ad0f6c1f 286#elif defined(ARCH_BFIN)
1a822d30
MH
287 MPV_common_init_bfin(s);
288#endif
676e200c 289
7604246d 290#ifdef CONFIG_ENCODERS
255eccab
BF
291 if(!s->dct_quantize)
292 s->dct_quantize= dct_quantize_c;
293 if(!s->denoise_dct)
294 s->denoise_dct= denoise_dct_c;
3a87ac94
MN
295 s->fast_dct_quantize= s->dct_quantize;
296
477ab036
MN
297 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
298 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
299 }
300
7604246d
WH
301#endif //CONFIG_ENCODERS
302
2ad1516a 303 /* load & permutate scantables
115329f1 304 note: only wmv uses different ones
2ad1516a 305 */
bb198e19
MN
306 if(s->alternate_scan){
307 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
308 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
309 }else{
310 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
311 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
312 }
3d2e8cce
MN
313 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
314 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
d930ef19 315
defdfc9a
AB
316 return 0;
317}
318
6571e41d
MN
319static void copy_picture(Picture *dst, Picture *src){
320 *dst = *src;
321 dst->type= FF_BUFFER_TYPE_COPY;
322}
323
62bb489b 324#ifdef CONFIG_ENCODERS
137c8468
MN
325static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
326 int i;
327
71c47d6e
MN
328 dst->pict_type = src->pict_type;
329 dst->quality = src->quality;
330 dst->coded_picture_number = src->coded_picture_number;
331 dst->display_picture_number = src->display_picture_number;
332// dst->reference = src->reference;
333 dst->pts = src->pts;
334 dst->interlaced_frame = src->interlaced_frame;
335 dst->top_field_first = src->top_field_first;
137c8468 336
a4d36c11
MN
337 if(s->avctx->me_threshold){
338 if(!src->motion_val[0])
339 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
340 if(!src->mb_type)
341 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
342 if(!src->ref_index[0])
343 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
137c8468 344 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
dfb706da 345 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
f4f3223f 346 src->motion_subsample_log2, dst->motion_subsample_log2);
a4d36c11
MN
347
348 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
115329f1 349
a4d36c11 350 for(i=0; i<2; i++){
137c8468
MN
351 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
352 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
353
a4d36c11
MN
354 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
355 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
356 }
357 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
7c4f71c4 358 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
a4d36c11 359 }
137c8468
MN
360 }
361 }
71c47d6e 362}
62bb489b 363#endif
71c47d6e 364
1e491e29 365/**
4e00e76b
MN
366 * allocates a Picture
367 * The pixels are allocated/set by calling get_buffer() if shared=0
1e491e29 368 */
4e00e76b 369static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
755bfeab 370 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
7bc9090a 371 const int mb_array_size= s->mb_stride*s->mb_height;
b40cd4e0
MN
372 const int b8_array_size= s->b8_stride*s->mb_height*2;
373 const int b4_array_size= s->b4_stride*s->mb_height*4;
0da71265 374 int i;
115329f1 375
4e00e76b
MN
376 if(shared){
377 assert(pic->data[0]);
378 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
379 pic->type= FF_BUFFER_TYPE_SHARED;
380 }else{
381 int r;
115329f1 382
4e00e76b 383 assert(!pic->data[0]);
115329f1 384
492cd3a9 385 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
115329f1 386
4e00e76b 387 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
bb270c08 388 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
389 return -1;
390 }
391
392 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
9b879566 393 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
4e00e76b
MN
394 return -1;
395 }
396
397 if(pic->linesize[1] != pic->linesize[2]){
bb628dae 398 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
4e00e76b
MN
399 return -1;
400 }
401
402 s->linesize = pic->linesize[0];
403 s->uvlinesize= pic->linesize[1];
1e491e29 404 }
115329f1 405
4e00e76b 406 if(pic->qscale_table==NULL){
115329f1 407 if (s->encoding) {
7bc9090a
MN
408 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
409 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
410 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
4e00e76b 411 }
1e491e29 412
7bc9090a 413 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
e4eadb4b 414 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
507a8e0d 415 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
7bc9090a 416 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
0da71265 417 if(s->out_format == FMT_H264){
0da71265 418 for(i=0; i<2; i++){
02dc8983
MN
419 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
420 pic->motion_val[i]= pic->motion_val_base[i]+4;
7c4f71c4 421 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
b40cd4e0 422 }
5ea4b18d 423 pic->motion_subsample_log2= 2;
0c9bbaec 424 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
b40cd4e0 425 for(i=0; i<2; i++){
02dc8983
MN
426 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
427 pic->motion_val[i]= pic->motion_val_base[i]+4;
7c4f71c4 428 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
0da71265 429 }
5ea4b18d 430 pic->motion_subsample_log2= 3;
0da71265 431 }
8289c6fa
WH
432 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
433 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
434 }
7bc9090a 435 pic->qstride= s->mb_stride;
fa384dcc 436 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
4e00e76b 437 }
0da71265 438
90b5b51e
DB
439 /* It might be nicer if the application would keep track of these
440 * but it would require an API change. */
f943e138
MN
441 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
442 s->prev_pict_types[0]= s->pict_type;
443 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
90b5b51e 444 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
115329f1 445
1e491e29
MN
446 return 0;
447fail: //for the CHECKED_ALLOCZ macro
448 return -1;
449}
450
4e00e76b
MN
451/**
452 * deallocates a picture
453 */
1e491e29
MN
454static void free_picture(MpegEncContext *s, Picture *pic){
455 int i;
4e00e76b
MN
456
457 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
492cd3a9 458 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
4e00e76b
MN
459 }
460
1e491e29
MN
461 av_freep(&pic->mb_var);
462 av_freep(&pic->mc_mb_var);
463 av_freep(&pic->mb_mean);
464 av_freep(&pic->mbskip_table);
465 av_freep(&pic->qscale_table);
0da71265 466 av_freep(&pic->mb_type_base);
8289c6fa 467 av_freep(&pic->dct_coeff);
fa384dcc 468 av_freep(&pic->pan_scan);
0da71265
MN
469 pic->mb_type= NULL;
470 for(i=0; i<2; i++){
b40cd4e0 471 av_freep(&pic->motion_val_base[i]);
0da71265
MN
472 av_freep(&pic->ref_index[i]);
473 }
115329f1 474
d90cf87b 475 if(pic->type == FF_BUFFER_TYPE_SHARED){
4e00e76b
MN
476 for(i=0; i<4; i++){
477 pic->base[i]=
478 pic->data[i]= NULL;
479 }
115329f1 480 pic->type= 0;
1e491e29
MN
481 }
482}
483
9c3d33d6
MN
484static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
485 int i;
486
115329f1 487 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
5d18eaad
LM
488 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
489 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
9c3d33d6 490
755bfeab 491 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
115329f1 492 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
9c3d33d6
MN
493 s->rd_scratchpad= s->me.scratchpad;
494 s->b_scratchpad= s->me.scratchpad;
495 s->obmc_scratchpad= s->me.scratchpad + 16;
496 if (s->encoding) {
497 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
498 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
499 if(s->avctx->noise_reduction){
500 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
501 }
115329f1 502 }
5e5c247a 503 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
9c3d33d6
MN
504 s->block= s->blocks[0];
505
506 for(i=0;i<12;i++){
507 s->pblocks[i] = (short *)(&s->block[i]);
508 }
509 return 0;
510fail:
511 return -1; //free() through MPV_common_end()
512}
513
514static void free_duplicate_context(MpegEncContext *s){
515 if(s==NULL) return;
516
517 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
518 av_freep(&s->me.scratchpad);
115329f1
DB
519 s->rd_scratchpad=
520 s->b_scratchpad=
9c3d33d6 521 s->obmc_scratchpad= NULL;
115329f1 522
9c3d33d6
MN
523 av_freep(&s->dct_error_sum);
524 av_freep(&s->me.map);
525 av_freep(&s->me.score_map);
526 av_freep(&s->blocks);
527 s->block= NULL;
528}
529
530static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
531#define COPY(a) bak->a= src->a
532 COPY(allocated_edge_emu_buffer);
533 COPY(edge_emu_buffer);
534 COPY(me.scratchpad);
535 COPY(rd_scratchpad);
536 COPY(b_scratchpad);
537 COPY(obmc_scratchpad);
538 COPY(me.map);
539 COPY(me.score_map);
540 COPY(blocks);
541 COPY(block);
542 COPY(start_mb_y);
543 COPY(end_mb_y);
544 COPY(me.map_generation);
545 COPY(pb);
546 COPY(dct_error_sum);
da16b204
MN
547 COPY(dct_count[0]);
548 COPY(dct_count[1]);
9c3d33d6
MN
549#undef COPY
550}
551
c62c07d3 552void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
9c3d33d6 553 MpegEncContext bak;
c62c07d3 554 int i;
9c3d33d6
MN
555 //FIXME copy only needed parts
556//START_TIMER
557 backup_duplicate_context(&bak, dst);
558 memcpy(dst, src, sizeof(MpegEncContext));
559 backup_duplicate_context(dst, &bak);
c62c07d3
MN
560 for(i=0;i<12;i++){
561 dst->pblocks[i] = (short *)(&dst->block[i]);
562 }
9c3d33d6
MN
563//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
564}
565
62bb489b 566#ifdef CONFIG_ENCODERS
9c3d33d6
MN
567static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
568#define COPY(a) dst->a= src->a
569 COPY(pict_type);
570 COPY(current_picture);
571 COPY(f_code);
572 COPY(b_code);
573 COPY(qscale);
574 COPY(lambda);
575 COPY(lambda2);
576 COPY(picture_in_gop_number);
577 COPY(gop_picture_number);
bb628dae
DB
578 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
579 COPY(progressive_frame); //FIXME don't set in encode_header
580 COPY(partitioned_frame); //FIXME don't set in encode_header
9c3d33d6
MN
581#undef COPY
582}
62bb489b 583#endif
9c3d33d6 584
3edcacde
MN
585/**
586 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
587 * the changed fields will not depend upon the prior state of the MpegEncContext.
588 */
589static void MPV_common_defaults(MpegEncContext *s){
590 s->y_dc_scale_table=
591 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
592 s->chroma_qscale_table= ff_default_chroma_qscale_table;
593 s->progressive_frame= 1;
594 s->progressive_sequence= 1;
595 s->picture_structure= PICT_FRAME;
596
597 s->coded_picture_number = 0;
598 s->picture_number = 0;
599 s->input_picture_number = 0;
600
601 s->picture_in_gop_number = 0;
7976241a
MN
602
603 s->f_code = 1;
604 s->b_code = 1;
3edcacde
MN
605}
606
607/**
608 * sets the given MpegEncContext to defaults for decoding.
609 * the changed fields will not depend upon the prior state of the MpegEncContext.
610 */
611void MPV_decode_defaults(MpegEncContext *s){
612 MPV_common_defaults(s);
613}
614
615/**
616 * sets the given MpegEncContext to defaults for encoding.
617 * the changed fields will not depend upon the prior state of the MpegEncContext.
618 */
6b47b730
MN
619
620#ifdef CONFIG_ENCODERS
e96682e6 621static void MPV_encode_defaults(MpegEncContext *s){
861450d5 622 int i;
3edcacde 623 MPV_common_defaults(s);
115329f1 624
861450d5
MN
625 for(i=-16; i<16; i++){
626 default_fcode_tab[i + MAX_MV]= 1;
3edcacde
MN
627 }
628 s->me.mv_penalty= default_mv_penalty;
629 s->fcode_tab= default_fcode_tab;
630}
6b47b730 631#endif //CONFIG_ENCODERS
3edcacde 632
115329f1 633/**
3edcacde
MN
634 * init common structure for both encoder and decoder.
635 * this assumes that some variables like width/height are already set
636 */
defdfc9a
AB
637int MPV_common_init(MpegEncContext *s)
638{
bb198e19 639 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
defdfc9a 640
fdb52bcc
LM
641 s->mb_height = (s->height + 15) / 16;
642
643 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
000a9c02
MN
644 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
645 return -1;
646 }
647
0ecca7a4
MN
648 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
649 return -1;
650
b0368839 651 dsputil_init(&s->dsp, s->avctx);
defdfc9a 652 DCT_common_init(s);
eb4b3dd3 653
9fee1e23 654 s->flags= s->avctx->flags;
303e50e6 655 s->flags2= s->avctx->flags2;
defdfc9a 656
1e491e29 657 s->mb_width = (s->width + 15) / 16;
7bc9090a 658 s->mb_stride = s->mb_width + 1;
b40cd4e0
MN
659 s->b8_stride = s->mb_width*2 + 1;
660 s->b4_stride = s->mb_width*4 + 1;
7bc9090a 661 mb_array_size= s->mb_height * s->mb_stride;
bb198e19 662 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
eb4b3dd3 663
ffdff4d7
IK
664 /* set chroma shifts */
665 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
666 &(s->chroma_y_shift) );
667
b5a093b3
MN
668 /* set default edge pos, will be overriden in decode_header if needed */
669 s->h_edge_pos= s->mb_width*16;
670 s->v_edge_pos= s->mb_height*16;
eb4b3dd3
ZK
671
672 s->mb_num = s->mb_width * s->mb_height;
115329f1 673
7bc9090a
MN
674 s->block_wrap[0]=
675 s->block_wrap[1]=
676 s->block_wrap[2]=
137c8468 677 s->block_wrap[3]= s->b8_stride;
7bc9090a 678 s->block_wrap[4]=
137c8468 679 s->block_wrap[5]= s->mb_stride;
115329f1 680
137c8468
MN
681 y_size = s->b8_stride * (2 * s->mb_height + 1);
682 c_size = s->mb_stride * (s->mb_height + 1);
eb4b3dd3 683 yc_size = y_size + 2 * c_size;
115329f1 684
202ef8b8 685 /* convert fourcc to upper case */
17662955 686 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
7004ffb3 687 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
115329f1 688 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
7004ffb3 689 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
b5a093b3 690
17662955 691 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
541ae140 692 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
115329f1 693 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
541ae140
MN
694 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
695
492cd3a9 696 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
1e491e29 697
7bc9090a
MN
698 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
699 for(y=0; y<s->mb_height; y++){
700 for(x=0; x<s->mb_width; x++){
701 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
702 }
703 }
704 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
115329f1 705
37fbfd0a 706 if (s->encoding) {
9dbcbd92 707 /* Allocate MV tables */
7bc9090a
MN
708 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
709 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
710 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
711 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
712 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
713 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
714 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
715 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
716 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
717 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
718 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
719 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
7f2fe444 720
6b460aa3
MN
721 if(s->msmpeg4_version){
722 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
723 }
3aa102be 724 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
7bc9090a
MN
725
726 /* Allocate MB type table */
bb198e19 727 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
115329f1 728
158c7f05 729 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
115329f1 730
7e4995c3
MN
731 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
732 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
642ccefb
MN
733 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
734 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
9d9e3172
MN
735 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
736 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
115329f1 737
821cb11f 738 if(s->avctx->noise_reduction){
821cb11f
MN
739 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
740 }
37fbfd0a 741 }
b465449e
MN
742 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
743
7bc9090a 744 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
115329f1 745
bb198e19 746 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
4d2858de 747 /* interlaced direct mode decoding tables */
bb198e19
MN
748 for(i=0; i<2; i++){
749 int j, k;
750 for(j=0; j<2; j++){
751 for(k=0; k<2; k++){
752 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
753 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
754 }
755 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
756 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
757 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
758 }
759 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
760 }
de6d9b64 761 }
6e2d5f1a 762 if (s->out_format == FMT_H263) {
de6d9b64 763 /* ac values */
137c8468
MN
764 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
765 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
766 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
de6d9b64 767 s->ac_val[2] = s->ac_val[1] + c_size;
115329f1 768
de6d9b64 769 /* cbp values */
137c8468
MN
770 CHECKED_ALLOCZ(s->coded_block_base, y_size);
771 s->coded_block= s->coded_block_base + s->b8_stride + 1;
115329f1 772
7f2fe444 773 /* cbp, ac_pred, pred_dir */
7bc9090a
MN
774 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
775 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
5b3438c6 776 }
115329f1 777
8b32880c
MN
778 if (s->h263_pred || s->h263_plus || !s->encoding) {
779 /* dc values */
780 //MN: we need these for error resilience of intra-frames
137c8468
MN
781 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
782 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
783 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
8b32880c
MN
784 s->dc_val[2] = s->dc_val[1] + c_size;
785 for(i=0;i<yc_size;i++)
137c8468 786 s->dc_val_base[i] = 1024;
8b32880c
MN
787 }
788
7806197d 789 /* which mb is a intra block */
7bc9090a
MN
790 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
791 memset(s->mbintra_table, 1, mb_array_size);
115329f1 792
3bb4e23a 793 /* init macroblock skip table */
7bc9090a 794 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
4d2858de 795 //Note the +1 is for a quicker mpeg4 slice_end detection
f943e138 796 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
115329f1 797
d7425f59 798 s->parse_context.state= -1;
0c9bbaec
WH
799 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
800 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
801 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
802 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
803 }
d7425f59 804
de6d9b64 805 s->context_initialized = 1;
9c3d33d6
MN
806
807 s->thread_context[0]= s;
808 for(i=1; i<s->avctx->thread_count; i++){
809 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
810 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
811 }
812
813 for(i=0; i<s->avctx->thread_count; i++){
814 if(init_duplicate_context(s->thread_context[i], s) < 0)
815 goto fail;
816 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
817 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
818 }
819
de6d9b64
FB
820 return 0;
821 fail:
8257bf05 822 MPV_common_end(s);
de6d9b64
FB
823 return -1;
824}
825
826/* init common structure for both encoder and decoder */
827void MPV_common_end(MpegEncContext *s)
828{
bb198e19 829 int i, j, k;
de6d9b64 830
9c3d33d6
MN
831 for(i=0; i<s->avctx->thread_count; i++){
832 free_duplicate_context(s->thread_context[i]);
833 }
834 for(i=1; i<s->avctx->thread_count; i++){
835 av_freep(&s->thread_context[i]);
836 }
837
147e5200
MN
838 av_freep(&s->parse_context.buffer);
839 s->parse_context.buffer_size=0;
840
6000abfa 841 av_freep(&s->mb_type);
7bc9090a
MN
842 av_freep(&s->p_mv_table_base);
843 av_freep(&s->b_forw_mv_table_base);
844 av_freep(&s->b_back_mv_table_base);
845 av_freep(&s->b_bidir_forw_mv_table_base);
846 av_freep(&s->b_bidir_back_mv_table_base);
847 av_freep(&s->b_direct_mv_table_base);
848 s->p_mv_table= NULL;
849 s->b_forw_mv_table= NULL;
850 s->b_back_mv_table= NULL;
851 s->b_bidir_forw_mv_table= NULL;
852 s->b_bidir_back_mv_table= NULL;
853 s->b_direct_mv_table= NULL;
bb198e19
MN
854 for(i=0; i<2; i++){
855 for(j=0; j<2; j++){
856 for(k=0; k<2; k++){
857 av_freep(&s->b_field_mv_table_base[i][j][k]);
858 s->b_field_mv_table[i][j][k]=NULL;
859 }
860 av_freep(&s->b_field_select_table[i][j]);
861 av_freep(&s->p_field_mv_table_base[i][j]);
862 s->p_field_mv_table[i][j]=NULL;
863 }
864 av_freep(&s->p_field_select_table[i]);
865 }
115329f1 866
137c8468
MN
867 av_freep(&s->dc_val_base);
868 av_freep(&s->ac_val_base);
869 av_freep(&s->coded_block_base);
6000abfa 870 av_freep(&s->mbintra_table);
7f2fe444
MN
871 av_freep(&s->cbp_table);
872 av_freep(&s->pred_dir_table);
115329f1 873
6000abfa 874 av_freep(&s->mbskip_table);
f943e138 875 av_freep(&s->prev_pict_types);
6000abfa 876 av_freep(&s->bitstream_buffer);
0ecca7a4
MN
877 s->allocated_bitstream_buffer_size=0;
878
3aa102be 879 av_freep(&s->avctx->stats_out);
6b460aa3 880 av_freep(&s->ac_stats);
4d2858de 881 av_freep(&s->error_status_table);
7bc9090a 882 av_freep(&s->mb_index2xy);
158c7f05 883 av_freep(&s->lambda_table);
7e4995c3
MN
884 av_freep(&s->q_intra_matrix);
885 av_freep(&s->q_inter_matrix);
642ccefb
MN
886 av_freep(&s->q_intra_matrix16);
887 av_freep(&s->q_inter_matrix16);
9d9e3172
MN
888 av_freep(&s->input_picture);
889 av_freep(&s->reordered_input_picture);
821cb11f 890 av_freep(&s->dct_offset);
1e491e29 891
9b4b6e09
MN
892 if(s->picture){
893 for(i=0; i<MAX_PICTURE_COUNT; i++){
894 free_picture(s, &s->picture[i]);
895 }
de6d9b64 896 }
b465449e 897 av_freep(&s->picture);
de6d9b64 898 s->context_initialized = 0;
431f2172
MN
899 s->last_picture_ptr=
900 s->next_picture_ptr=
901 s->current_picture_ptr= NULL;
b100eab8 902 s->linesize= s->uvlinesize= 0;
8100cab9 903
0c9bbaec 904 for(i=0; i<3; i++)
8100cab9 905 av_freep(&s->visualization_buffer[i]);
b100eab8
MN
906
907 avcodec_default_free_buffers(s->avctx);
de6d9b64
FB
908}
909
7604246d
WH
910#ifdef CONFIG_ENCODERS
911
de6d9b64
FB
912/* init video encoder */
913int MPV_encode_init(AVCodecContext *avctx)
914{
915 MpegEncContext *s = avctx->priv_data;
bf4e3bd2 916 int i;
b1e6b355 917 int chroma_h_shift, chroma_v_shift;
115329f1 918
3edcacde 919 MPV_encode_defaults(s);
bc657ac3 920
2d974017
BC
921 switch (avctx->codec_id) {
922 case CODEC_ID_MPEG2VIDEO:
923 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
924 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
925 return -1;
926 }
927 break;
928 case CODEC_ID_LJPEG:
929 case CODEC_ID_MJPEG:
2bb78759
BC
930 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
931 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
dd4f8a04
MN
932 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
933 return -1;
934 }
2d974017
BC
935 break;
936 default:
937 if(avctx->pix_fmt != PIX_FMT_YUV420P){
938 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
dd4f8a04
MN
939 return -1;
940 }
941 }
36b58e85 942
2d974017
BC
943 switch (avctx->pix_fmt) {
944 case PIX_FMT_YUVJ422P:
945 case PIX_FMT_YUV422P:
946 s->chroma_format = CHROMA_422;
947 break;
948 case PIX_FMT_YUVJ420P:
949 case PIX_FMT_YUV420P:
950 default:
951 s->chroma_format = CHROMA_420;
952 break;
953 }
954
de6d9b64 955 s->bit_rate = avctx->bit_rate;
de6d9b64
FB
956 s->width = avctx->width;
957 s->height = avctx->height;
d4277a7d 958 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
bb270c08 959 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
7f2fe444
MN
960 avctx->gop_size=600;
961 }
de6d9b64 962 s->gop_size = avctx->gop_size;
477c35a9 963 s->avctx = avctx;
ba6802de 964 s->flags= avctx->flags;
303e50e6 965 s->flags2= avctx->flags2;
9dbcbd92 966 s->max_b_frames= avctx->max_b_frames;
d7e9533a 967 s->codec_id= avctx->codec->id;
7f2fe444
MN
968 s->luma_elim_threshold = avctx->luma_elim_threshold;
969 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
970 s->strict_std_compliance= avctx->strict_std_compliance;
971 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
1457ab52 972 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
87f8cab4 973 s->mpeg_quant= avctx->mpeg_quant;
ba58dabc 974 s->rtp_mode= !!avctx->rtp_payload_size;
bf266e19 975 s->intra_dc_precision= avctx->intra_dc_precision;
9ebb8e11 976 s->user_specified_pts = AV_NOPTS_VALUE;
e4eadb4b 977
de6d9b64
FB
978 if (s->gop_size <= 1) {
979 s->intra_only = 1;
980 s->gop_size = 12;
981 } else {
982 s->intra_only = 0;
983 }
5e746b99 984
1457ab52 985 s->me_method = avctx->me_method;
5e746b99 986
e4986da9 987 /* Fixed QSCALE */
bb198e19 988 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
115329f1 989
c5d309f2 990 s->adaptive_quant= ( s->avctx->lumi_masking
5e746b99 991 || s->avctx->dark_masking
115329f1 992 || s->avctx->temporal_cplx_masking
c5d309f2 993 || s->avctx->spatial_cplx_masking
1f26c6f3 994 || s->avctx->p_masking
957c743a 995 || s->avctx->border_masking
1f26c6f3 996 || (s->flags&CODEC_FLAG_QP_RD))
c5d309f2 997 && !s->fixed_qscale;
115329f1 998
bb198e19
MN
999 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1000 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1001 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
307eb248 1002 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
5a6b9443 1003 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
5e746b99 1004
273977d8
MN
1005 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1006 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1007 return -1;
115329f1 1008 }
273977d8
MN
1009
1010 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
dfb706da 1011 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
b73afeac 1012 }
115329f1 1013
23854cad 1014 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
db7f647e 1015 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
23854cad
MN
1016 return -1;
1017 }
115329f1 1018
23854cad
MN
1019 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1020 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1021 return -1;
1022 }
115329f1 1023
64be2e60 1024 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){
db7f647e 1025 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
64be2e60
MN
1026 return -1;
1027 }
1028
1029 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){
db7f647e 1030 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n");
64be2e60
MN
1031 return -1;
1032 }
1033
115329f1 1034 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
b73afeac
MN
1035 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1036 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
115329f1 1037
b73afeac
MN
1038 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");
1039 }
115329f1
DB
1040
1041 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
747a0554 1042 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
9b879566 1043 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
9acbbd16
MN
1044 return -1;
1045 }
115329f1 1046
f7190f73 1047 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
dfb706da 1048 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
f7190f73
MN
1049 return -1;
1050 }
115329f1 1051
332f9ac4
MN
1052 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1053 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1054 return -1;
1055 }
115329f1 1056
9acbbd16 1057 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
9b879566 1058 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
9acbbd16
MN
1059 return -1;
1060 }
1061
1062 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
9b879566 1063 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
9acbbd16
MN
1064 return -1;
1065 }
115329f1 1066
029911d1 1067 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
9b879566 1068 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
9acbbd16
MN
1069 return -1;
1070 }
1671083f 1071
115329f1 1072 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1671083f
MN
1073 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1074 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1075 return -1;
1076 }
115329f1 1077
9acbbd16 1078 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
dfb706da 1079 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
9acbbd16
MN
1080 return -1;
1081 }
115329f1 1082
f2f6134b 1083 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
9b879566 1084 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
f2f6134b
MN
1085 return -1;
1086 }
1087
dd3e415e
MN
1088 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1089 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1090 return -1;
1091 }
115329f1 1092
303e50e6 1093 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
9d57fd9b 1094 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
303e50e6
MN
1095 return -1;
1096 }
115329f1 1097
307eb248
BC
1098 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1099 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1100 return -1;
1101 }
1102
9cc6be9d
BC
1103 if(s->flags & CODEC_FLAG_LOW_DELAY){
1104 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1105 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1106 return -1;
1107 }
1108 if (s->max_b_frames != 0){
1109 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1110 return -1;
1111 }
1112 }
1113
5a6b9443
BC
1114 if(s->q_scale_type == 1){
1115 if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1116 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1117 return -1;
1118 }
1119 if(avctx->qmax > 12){
1120 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1121 return -1;
1122 }
1123 }
1124
115329f1
DB
1125 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1126 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
9c3d33d6
MN
1127 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1128 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1129 return -1;
1130 }
115329f1 1131
9c3d33d6
MN
1132 if(s->avctx->thread_count > 1)
1133 s->rtp_mode= 1;
11a8a71d 1134
c0df9d75 1135 if(!avctx->time_base.den || !avctx->time_base.num){
e8ea9012
MN
1136 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1137 return -1;
1138 }
115329f1 1139
cec1f05f
MN
1140 i= (INT_MAX/2+128)>>8;
1141 if(avctx->me_threshold >= i){
1142 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1143 return -1;
1144 }
1145 if(avctx->mb_threshold >= i){
1146 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1147 return -1;
1148 }
115329f1 1149
bf873ee6 1150 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
b29183a1
CH
1151 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1152 avctx->b_frame_strategy = 0;
bf873ee6
MN
1153 }
1154
c0df9d75 1155 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
11a8a71d
MN
1156 if(i > 1){
1157 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
c0df9d75
MN
1158 avctx->time_base.den /= i;
1159 avctx->time_base.num /= i;
11a8a71d
MN
1160// return -1;
1161 }
115329f1 1162
1984f635
MN
1163 if(s->codec_id==CODEC_ID_MJPEG){
1164 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1165 s->inter_quant_bias= 0;
029911d1 1166 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1984f635
MN
1167 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1168 s->inter_quant_bias= 0;
1169 }else{
1170 s->intra_quant_bias=0;
1171 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1172 }
115329f1 1173
1984f635
MN
1174 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1175 s->intra_quant_bias= avctx->intra_quant_bias;
1176 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1177 s->inter_quant_bias= avctx->inter_quant_bias;
115329f1 1178
b1e6b355
MN
1179 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1180
1192ce37 1181 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
c0df9d75 1182 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
115329f1 1183 return -1;
c0df9d75
MN
1184 }
1185 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
22ddd60b 1186
de6d9b64
FB
1187 switch(avctx->codec->id) {
1188 case CODEC_ID_MPEG1VIDEO:
1189 s->out_format = FMT_MPEG1;
9cc6be9d 1190 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
14bea432 1191 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1192 break;
029911d1
MN
1193 case CODEC_ID_MPEG2VIDEO:
1194 s->out_format = FMT_MPEG1;
9cc6be9d 1195 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
029911d1 1196 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
ba58dabc 1197 s->rtp_mode= 1;
029911d1 1198 break;
b1e6b355 1199 case CODEC_ID_LJPEG:
de6d9b64
FB
1200 case CODEC_ID_MJPEG:
1201 s->out_format = FMT_MJPEG;
1202 s->intra_only = 1; /* force intra only for jpeg */
2bb78759
BC
1203 s->mjpeg_vsample[0] = 2;
1204 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1205 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1206 s->mjpeg_hsample[0] = 2;
1207 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1208 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
44301eaa
AJ
1209 if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER)
1210 || ff_mjpeg_encode_init(s) < 0)
de6d9b64 1211 return -1;
1ff662cc 1212 avctx->delay=0;
4e00e76b 1213 s->low_delay=1;
de6d9b64 1214 break;
1c3990db 1215 case CODEC_ID_H261:
70724cba 1216 if (!ENABLE_H261_ENCODER) return -1;
a57d13b7
BC
1217 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1218 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
1219 return -1;
1220 }
1c3990db
MN
1221 s->out_format = FMT_H261;
1222 avctx->delay=0;
1223 s->low_delay=1;
1224 break;
de6d9b64 1225 case CODEC_ID_H263:
37fbfd0a 1226 if (h263_get_picture_format(s->width, s->height) == 7) {
ee0d2803 1227 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
de6d9b64 1228 return -1;
37fbfd0a 1229 }
de6d9b64 1230 s->out_format = FMT_H263;
bb270c08 1231 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1ff662cc 1232 avctx->delay=0;
4e00e76b 1233 s->low_delay=1;
de6d9b64
FB
1234 break;
1235 case CODEC_ID_H263P:
1236 s->out_format = FMT_H263;
1237 s->h263_plus = 1;
bb270c08 1238 /* Fx */
332f9ac4 1239 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
6b936ec6 1240 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
bb270c08
DB
1241 s->modified_quant= s->h263_aic;
1242 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1243 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1244 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1245 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
ba58dabc 1246 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
332f9ac4 1247
bb270c08 1248 /* /Fx */
544286b3 1249 /* These are just to be sure */
1ff662cc 1250 avctx->delay=0;
4e00e76b 1251 s->low_delay=1;
de6d9b64 1252 break;
d4f5d74a
GM
1253 case CODEC_ID_FLV1:
1254 s->out_format = FMT_H263;
1255 s->h263_flv = 2; /* format = 1; 11-bit codes */
1256 s->unrestricted_mv = 1;
1257 s->rtp_mode=0; /* don't allow GOB */
1258 avctx->delay=0;
1259 s->low_delay=1;
1260 break;
de6d9b64
FB
1261 case CODEC_ID_RV10:
1262 s->out_format = FMT_H263;
1ff662cc 1263 avctx->delay=0;
4e00e76b 1264 s->low_delay=1;
de6d9b64 1265 break;
d0271e8a
MN
1266 case CODEC_ID_RV20:
1267 s->out_format = FMT_H263;
1268 avctx->delay=0;
1269 s->low_delay=1;
1270 s->modified_quant=1;
1271 s->h263_aic=1;
1272 s->h263_plus=1;
1273 s->loop_filter=1;
1274 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1275 break;
58f26ba9 1276 case CODEC_ID_MPEG4:
de6d9b64
FB
1277 s->out_format = FMT_H263;
1278 s->h263_pred = 1;
1279 s->unrestricted_mv = 1;
4e00e76b 1280 s->low_delay= s->max_b_frames ? 0 : 1;
4d2858de 1281 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
de6d9b64 1282 break;
84afee34 1283 case CODEC_ID_MSMPEG4V1:
de6d9b64
FB
1284 s->out_format = FMT_H263;
1285 s->h263_msmpeg4 = 1;
1286 s->h263_pred = 1;
1287 s->unrestricted_mv = 1;
84afee34 1288 s->msmpeg4_version= 1;
1ff662cc 1289 avctx->delay=0;
4e00e76b 1290 s->low_delay=1;
84afee34
MN
1291 break;
1292 case CODEC_ID_MSMPEG4V2:
1293 s->out_format = FMT_H263;
1294 s->h263_msmpeg4 = 1;
1295 s->h263_pred = 1;
1296 s->unrestricted_mv = 1;
1297 s->msmpeg4_version= 2;
1ff662cc 1298 avctx->delay=0;
4e00e76b 1299 s->low_delay=1;
84afee34
MN
1300 break;
1301 case CODEC_ID_MSMPEG4V3:
1302 s->out_format = FMT_H263;
1303 s->h263_msmpeg4 = 1;
1304 s->h263_pred = 1;
1305 s->unrestricted_mv = 1;
1306 s->msmpeg4_version= 3;
1f9aea9b 1307 s->flipflop_rounding=1;
1ff662cc 1308 avctx->delay=0;
4e00e76b 1309 s->low_delay=1;
de6d9b64 1310 break;
f5957f3f
MN
1311 case CODEC_ID_WMV1:
1312 s->out_format = FMT_H263;
1313 s->h263_msmpeg4 = 1;
1314 s->h263_pred = 1;
1315 s->unrestricted_mv = 1;
1316 s->msmpeg4_version= 4;
1f9aea9b 1317 s->flipflop_rounding=1;
f5957f3f 1318 avctx->delay=0;
4e00e76b 1319 s->low_delay=1;
f5957f3f
MN
1320 break;
1321 case CODEC_ID_WMV2:
1322 s->out_format = FMT_H263;
1323 s->h263_msmpeg4 = 1;
1324 s->h263_pred = 1;
1325 s->unrestricted_mv = 1;
1326 s->msmpeg4_version= 5;
1f9aea9b 1327 s->flipflop_rounding=1;
f5957f3f 1328 avctx->delay=0;
4e00e76b 1329 s->low_delay=1;
f5957f3f 1330 break;
de6d9b64
FB
1331 default:
1332 return -1;
1333 }
115329f1 1334
57518155 1335 avctx->has_b_frames= !s->low_delay;
2c492e94 1336
3bb4e23a
FB
1337 s->encoding = 1;
1338
de6d9b64
FB
1339 /* init */
1340 if (MPV_common_init(s) < 0)
1341 return -1;
dd5e90cd
MN
1342
1343 if(s->modified_quant)
1344 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
115329f1 1345 s->progressive_frame=
45f3704c 1346 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
9c3d33d6 1347 s->quant_precision=5;
115329f1 1348
622348f9 1349 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
0fd6aea1 1350 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
115329f1 1351
70724cba 1352 if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
1c3990db 1353 ff_h261_encode_init(s);
2ad1516a
MN
1354 if (s->out_format == FMT_H263)
1355 h263_encode_init(s);
15025553 1356 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
2ad1516a 1357 ff_msmpeg4_encode_init(s);
1d0d55da
MN
1358 if (s->out_format == FMT_MPEG1)
1359 ff_mpeg1_encode_init(s);
2ad1516a 1360
3edcacde 1361 /* init q matrix */
519c2b6d 1362 for(i=0;i<64;i++) {
b0368839 1363 int j= s->dsp.idct_permutation[i];
87f8cab4 1364 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
2ad1516a
MN
1365 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1366 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1c3990db 1367 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
2ad1516a
MN
1368 s->intra_matrix[j] =
1369 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1d0d55da 1370 }else
029911d1 1371 { /* mpeg1/2 */
2ad1516a
MN
1372 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1373 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
87f8cab4 1374 }
d6eb3c50
MN
1375 if(s->avctx->intra_matrix)
1376 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1377 if(s->avctx->inter_matrix)
1378 s->inter_matrix[j] = s->avctx->inter_matrix[i];
d7e9533a
MN
1379 }
1380
1381 /* precompute matrix */
ef5b1b5a 1382 /* for mjpeg, we do include qscale in the matrix */
d7e9533a 1383 if (s->out_format != FMT_MJPEG) {
115329f1 1384 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
732ce18e 1385 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
115329f1 1386 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
732ce18e 1387 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
519c2b6d
FB
1388 }
1389
8b4c7dbc
MN
1390 if(ff_rate_control_init(s) < 0)
1391 return -1;
115329f1 1392
de6d9b64
FB
1393 return 0;
1394}
1395
1396int MPV_encode_end(AVCodecContext *avctx)
1397{
1398 MpegEncContext *s = avctx->priv_data;
1399
8b4c7dbc
MN
1400 ff_rate_control_uninit(s);
1401
de6d9b64 1402 MPV_common_end(s);
f6993c9f 1403 if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG)
44301eaa 1404 ff_mjpeg_encode_close(s);
541ae140 1405
22ddd60b 1406 av_freep(&avctx->extradata);
115329f1 1407
de6d9b64
FB
1408 return 0;
1409}
1410
7604246d
WH
1411#endif //CONFIG_ENCODERS
1412
3502a54f 1413void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
1d0d55da 1414{
0c1a9eda
ZK
1415 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1416 uint8_t index_run[MAX_RUN+1];
1d0d55da
MN
1417 int last, run, level, start, end, i;
1418
073c2593 1419 /* If table is static, we can quit if rl->max_level[0] is not NULL */
3502a54f 1420 if(static_store && rl->max_level[0])
073c2593
BP
1421 return;
1422
1d0d55da
MN
1423 /* compute max_level[], max_run[] and index_run[] */
1424 for(last=0;last<2;last++) {
1425 if (last == 0) {
1426 start = 0;
1427 end = rl->last;
1428 } else {
1429 start = rl->last;
1430 end = rl->n;
1431 }
1432
1433 memset(max_level, 0, MAX_RUN + 1);
1434 memset(max_run, 0, MAX_LEVEL + 1);
1435 memset(index_run, rl->n, MAX_RUN + 1);
1436 for(i=start;i<end;i++) {
1437 run = rl->table_run[i];
1438 level = rl->table_level[i];
1439 if (index_run[run] == rl->n)
1440 index_run[run] = i;
1441 if (level > max_level[run])
1442 max_level[run] = level;
1443 if (run > max_run[level])
1444 max_run[level] = run;
1445 }
3502a54f
MN
1446 if(static_store)
1447 rl->max_level[last] = static_store[last];
073c2593
BP
1448 else
1449 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1d0d55da 1450 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
3502a54f
MN
1451 if(static_store)
1452 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
073c2593
BP
1453 else
1454 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1d0d55da 1455 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
3502a54f
MN
1456 if(static_store)
1457 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
073c2593
BP
1458 else
1459 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1d0d55da
MN
1460 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1461 }
1462}
1463
de6d9b64 1464/* draw the edges of width 'w' of an image of size width, height */
fd7db0fd 1465//FIXME check that this is ok for mpeg4 interlaced
0c1a9eda 1466static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
de6d9b64 1467{
0c1a9eda 1468 uint8_t *ptr, *last_line;
de6d9b64
FB
1469 int i;
1470
1471 last_line = buf + (height - 1) * wrap;
1472 for(i=0;i<w;i++) {
1473 /* top and bottom */
1474 memcpy(buf - (i + 1) * wrap, buf, width);
1475 memcpy(last_line + (i + 1) * wrap, last_line, width);
1476 }
1477 /* left and right */
1478 ptr = buf;
1479 for(i=0;i<height;i++) {
1480 memset(ptr - w, ptr[0], w);
1481 memset(ptr + width, ptr[width-1], w);
1482 ptr += wrap;
1483 }
1484 /* corners */
1485 for(i=0;i<w;i++) {
1486 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1487 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1488 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1489 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1490 }
1491}
1492
5f194811 1493int ff_find_unused_picture(MpegEncContext *s, int shared){
4e00e76b 1494 int i;
115329f1 1495
4e00e76b
MN
1496 if(shared){
1497 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1498 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
4e00e76b
MN
1499 }
1500 }else{
1501 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1502 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
4e00e76b
MN
1503 }
1504 for(i=0; i<MAX_PICTURE_COUNT; i++){
5f194811 1505 if(s->picture[i].data[0]==NULL) return i;
4e00e76b
MN
1506 }
1507 }
1508
5f194811
MN
1509 assert(0);
1510 return -1;
4e00e76b
MN
1511}
1512
821cb11f
MN
1513static void update_noise_reduction(MpegEncContext *s){
1514 int intra, i;
1515
1516 for(intra=0; intra<2; intra++){
1517 if(s->dct_count[intra] > (1<<16)){
1518 for(i=0; i<64; i++){
1519 s->dct_error_sum[intra][i] >>=1;
1520 }
1521 s->dct_count[intra] >>= 1;
1522 }
115329f1 1523
821cb11f
MN
1524 for(i=0; i<64; i++){
1525 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);
1526 }
1527 }
1528}
1529
5f194811
MN
1530/**
1531 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1532 */
d6db1c9c 1533int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
de6d9b64 1534{
4e00e76b 1535 int i;
492cd3a9 1536 AVFrame *pic;
160d679c 1537 s->mb_skipped = 0;
0da71265 1538
8b82a956 1539 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
e20c4069 1540
1e491e29 1541 /* mark&release old frames */
14e2a940 1542 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
6ad7cd04 1543 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
b536d0aa 1544 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1e491e29
MN
1545
1546 /* release forgotten pictures */
1547 /* if(mpeg124/h263) */
1548 if(!s->encoding){
1549 for(i=0; i<MAX_PICTURE_COUNT; i++){
b536d0aa 1550 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
9b879566 1551 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
115329f1 1552 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1e491e29
MN
1553 }
1554 }
d6db1c9c 1555 }
6ad7cd04 1556 }
93a21abd 1557 }
aa388dba
MN
1558alloc:
1559 if(!s->encoding){
bb628dae 1560 /* release non reference frames */
e20c4069
MN
1561 for(i=0; i<MAX_PICTURE_COUNT; i++){
1562 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1563 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1564 }
1565 }
1566
5f194811
MN
1567 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1568 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1569 else{
1570 i= ff_find_unused_picture(s, 0);
1571 pic= (AVFrame*)&s->picture[i];
1572 }
1573
2f944356
LM
1574 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1575 && !s->dropable ? 3 : 0;
b536d0aa 1576
1031fabd 1577 pic->coded_picture_number= s->coded_picture_number++;
115329f1 1578
f23a68df
IK
1579 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1580 return -1;
93a21abd 1581
5f194811 1582 s->current_picture_ptr= (Picture*)pic;
c70f1716 1583 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
2be9f03a 1584 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1e491e29 1585 }
b7adc711 1586
9f2e61b6 1587 s->current_picture_ptr->pict_type= s->pict_type;
115329f1 1588// if(s->flags && CODEC_FLAG_QSCALE)
158c7f05 1589 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
7bc9090a 1590 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
9f2e61b6 1591
6571e41d 1592 copy_picture(&s->current_picture, s->current_picture_ptr);
115329f1 1593
1e491e29 1594 if (s->pict_type != B_TYPE) {
b536d0aa 1595 s->last_picture_ptr= s->next_picture_ptr;
14e2a940
MN
1596 if(!s->dropable)
1597 s->next_picture_ptr= s->current_picture_ptr;
de6d9b64 1598 }
14e2a940 1599/* 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,
115329f1
DB
1600 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1601 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
14e2a940
MN
1602 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1603 s->pict_type, s->dropable);*/
115329f1 1604
6571e41d
MN
1605 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1606 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
115329f1 1607
1fdefd98 1608 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
9b879566 1609 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
bb628dae 1610 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
ffba1dc0
MN
1611 goto alloc;
1612 }
1613
1614 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1615
b536d0aa
MN
1616 if(s->picture_structure!=PICT_FRAME){
1617 int i;
1618 for(i=0; i<4; i++){
1619 if(s->picture_structure == PICT_BOTTOM_FIELD){
1620 s->current_picture.data[i] += s->current_picture.linesize[i];
115329f1 1621 }
b536d0aa
MN
1622 s->current_picture.linesize[i] *= 2;
1623 s->last_picture.linesize[i] *=2;
1624 s->next_picture.linesize[i] *=2;
1625 }
1626 }
115329f1 1627
aa388dba
MN
1628 s->hurry_up= s->avctx->hurry_up;
1629 s->error_resilience= avctx->error_resilience;
1630
bb628dae 1631 /* set dequantizer, we can't do it during init as it might change for mpeg4
755bfeab 1632 and we can't do it in the header decode as init is not called for mpeg4 there yet */
d50635cd
MN
1633 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1634 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1635 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
ccff9da6 1636 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
d50635cd
MN
1637 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1638 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1639 }else{
1640 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1641 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1642 }
d6db1c9c 1643
821cb11f
MN
1644 if(s->dct_error_sum){
1645 assert(s->avctx->noise_reduction && s->encoding);
1646
1647 update_noise_reduction(s);
1648 }
115329f1 1649
2e7b4c84
IK
1650#ifdef HAVE_XVMC
1651 if(s->avctx->xvmc_acceleration)
1652 return XVMC_field_start(s, avctx);
1653#endif
d6db1c9c 1654 return 0;
de6d9b64 1655}
21af69f7 1656
de6d9b64
FB
1657/* generic function for encode/decode called after a frame has been coded/decoded */
1658void MPV_frame_end(MpegEncContext *s)
1659{
1e491e29 1660 int i;
de6d9b64 1661 /* draw edge for correct motion prediction if outside */
2e7b4c84
IK
1662#ifdef HAVE_XVMC
1663//just to make sure that all data is rendered.
1664 if(s->avctx->xvmc_acceleration){
1665 XVMC_field_end(s);
1666 }else
1667#endif
2f944356 1668 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1e491e29
MN
1669 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1670 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1671 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
de6d9b64 1672 }
5975626d 1673 emms_c();
115329f1 1674
3aa102be 1675 s->last_pict_type = s->pict_type;
88e51e1f 1676 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
8b4c7dbc
MN
1677 if(s->pict_type!=B_TYPE){
1678 s->last_non_b_pict_type= s->pict_type;
8b4c7dbc 1679 }
b536d0aa
MN
1680#if 0
1681 /* copy back current_picture variables */
1e491e29
MN
1682 for(i=0; i<MAX_PICTURE_COUNT; i++){
1683 if(s->picture[i].data[0] == s->current_picture.data[0]){
1684 s->picture[i]= s->current_picture;
1685 break;
115329f1 1686 }
1e491e29
MN
1687 }
1688 assert(i<MAX_PICTURE_COUNT);
115329f1 1689#endif
1e491e29 1690
e20c4069 1691 if(s->encoding){
bb628dae 1692 /* release non-reference frames */
e20c4069
MN
1693 for(i=0; i<MAX_PICTURE_COUNT; i++){
1694 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1695 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1696 }
1697 }
1e491e29 1698 }
b536d0aa
MN
1699 // clear copies, to avoid confusion
1700#if 0
1701 memset(&s->last_picture, 0, sizeof(Picture));
1702 memset(&s->next_picture, 0, sizeof(Picture));
1703 memset(&s->current_picture, 0, sizeof(Picture));
1704#endif
7b37a6e9 1705 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
de6d9b64
FB
1706}
1707
7bc9090a 1708/**
db6e7795
MN
1709 * draws an line from (ex, ey) -> (sx, sy).
1710 * @param w width of the image
1711 * @param h height of the image
1712 * @param stride stride/linesize of the image
1713 * @param color color of the arrow
1714 */
1715static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
67eca72d 1716 int x, y, fr, f;
115329f1 1717
f66e4f5f
RD
1718 sx= av_clip(sx, 0, w-1);
1719 sy= av_clip(sy, 0, h-1);
1720 ex= av_clip(ex, 0, w-1);
1721 ey= av_clip(ey, 0, h-1);
115329f1 1722
db6e7795 1723 buf[sy*stride + sx]+= color;
115329f1 1724
c26abfa5 1725 if(FFABS(ex - sx) > FFABS(ey - sy)){
db6e7795 1726 if(sx > ex){
1345f4ed
DB
1727 FFSWAP(int, sx, ex);
1728 FFSWAP(int, sy, ey);
db6e7795
MN
1729 }
1730 buf+= sx + sy*stride;
1731 ex-= sx;
1732 f= ((ey-sy)<<16)/ex;
1733 for(x= 0; x <= ex; x++){
8100cab9
MN
1734 y = (x*f)>>16;
1735 fr= (x*f)&0xFFFF;
1736 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1737 buf[(y+1)*stride + x]+= (color* fr )>>16;
db6e7795
MN
1738 }
1739 }else{
1740 if(sy > ey){
1345f4ed
DB
1741 FFSWAP(int, sx, ex);
1742 FFSWAP(int, sy, ey);
db6e7795
MN
1743 }
1744 buf+= sx + sy*stride;
1745 ey-= sy;
1746 if(ey) f= ((ex-sx)<<16)/ey;
1747 else f= 0;
1748 for(y= 0; y <= ey; y++){
8100cab9
MN
1749 x = (y*f)>>16;
1750 fr= (y*f)&0xFFFF;
1751 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1752 buf[y*stride + x+1]+= (color* fr )>>16;;
db6e7795
MN
1753 }
1754 }
1755}
1756
1757/**
1758 * draws an arrow from (ex, ey) -> (sx, sy).
1759 * @param w width of the image
1760 * @param h height of the image
1761 * @param stride stride/linesize of the image
1762 * @param color color of the arrow
1763 */
115329f1 1764static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
db6e7795
MN
1765 int dx,dy;
1766
f66e4f5f
RD
1767 sx= av_clip(sx, -100, w+100);
1768 sy= av_clip(sy, -100, h+100);
1769 ex= av_clip(ex, -100, w+100);
1770 ey= av_clip(ey, -100, h+100);
115329f1 1771
db6e7795
MN
1772 dx= ex - sx;
1773 dy= ey - sy;
115329f1 1774
db6e7795
MN
1775 if(dx*dx + dy*dy > 3*3){
1776 int rx= dx + dy;
1777 int ry= -dx + dy;
1778 int length= ff_sqrt((rx*rx + ry*ry)<<8);
115329f1 1779
db6e7795
MN
1780 //FIXME subpixel accuracy
1781 rx= ROUNDED_DIV(rx*3<<4, length);
1782 ry= ROUNDED_DIV(ry*3<<4, length);
115329f1 1783
db6e7795
MN
1784 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1785 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1786 }
1787 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1788}
1789
1790/**
7bc9090a
MN
1791 * prints debuging info for the given picture.
1792 */
0c9bbaec 1793void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
7bc9090a
MN
1794
1795 if(!pict || !pict->mb_type) return;
1796
1797 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1798 int x,y;
115329f1 1799
0c9bbaec
WH
1800 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1801 switch (pict->pict_type) {
1802 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1803 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1804 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1805 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1806 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
115329f1 1807 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
0c9bbaec 1808 }
7bc9090a
MN
1809 for(y=0; y<s->mb_height; y++){
1810 for(x=0; x<s->mb_width; x++){
1811 if(s->avctx->debug&FF_DEBUG_SKIP){
1812 int count= s->mbskip_table[x + y*s->mb_stride];
1813 if(count>9) count=9;
9b879566 1814 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
7bc9090a
MN
1815 }
1816 if(s->avctx->debug&FF_DEBUG_QP){
9b879566 1817 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
7bc9090a
MN
1818 }
1819 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1820 int mb_type= pict->mb_type[x + y*s->mb_stride];
7bc9090a
MN
1821 //Type & MV direction
1822 if(IS_PCM(mb_type))
9b879566 1823 av_log(s->avctx, AV_LOG_DEBUG, "P");
7bc9090a 1824 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
9b879566 1825 av_log(s->avctx, AV_LOG_DEBUG, "A");
7bc9090a 1826 else if(IS_INTRA4x4(mb_type))
9b879566 1827 av_log(s->avctx, AV_LOG_DEBUG, "i");
7bc9090a 1828 else if(IS_INTRA16x16(mb_type))
9b879566 1829 av_log(s->avctx, AV_LOG_DEBUG, "I");
7bc9090a 1830 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
9b879566 1831 av_log(s->avctx, AV_LOG_DEBUG, "d");
7bc9090a 1832 else if(IS_DIRECT(mb_type))
9b879566 1833 av_log(s->avctx, AV_LOG_DEBUG, "D");
7bc9090a 1834 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
9b879566 1835 av_log(s->avctx, AV_LOG_DEBUG, "g");
7bc9090a 1836 else if(IS_GMC(mb_type))
9b879566 1837 av_log(s->avctx, AV_LOG_DEBUG, "G");
7bc9090a 1838 else if(IS_SKIP(mb_type))
9b879566 1839 av_log(s->avctx, AV_LOG_DEBUG, "S");
7bc9090a 1840 else if(!USES_LIST(mb_type, 1))
9b879566 1841 av_log(s->avctx, AV_LOG_DEBUG, ">");
7bc9090a 1842 else if(!USES_LIST(mb_type, 0))
9b879566 1843 av_log(s->avctx, AV_LOG_DEBUG, "<");
7bc9090a
MN
1844 else{
1845 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
9b879566 1846 av_log(s->avctx, AV_LOG_DEBUG, "X");
7bc9090a 1847 }
115329f1 1848
7bc9090a
MN
1849 //segmentation
1850 if(IS_8X8(mb_type))
9b879566 1851 av_log(s->avctx, AV_LOG_DEBUG, "+");
7bc9090a 1852 else if(IS_16X8(mb_type))
9b879566 1853 av_log(s->avctx, AV_LOG_DEBUG, "-");
7bc9090a 1854 else if(IS_8X16(mb_type))
30344a83 1855 av_log(s->avctx, AV_LOG_DEBUG, "|");
7bc9090a 1856 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
9b879566 1857 av_log(s->avctx, AV_LOG_DEBUG, " ");
7bc9090a 1858 else
9b879566 1859 av_log(s->avctx, AV_LOG_DEBUG, "?");
115329f1
DB
1860
1861
7bc9090a 1862 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
9b879566 1863 av_log(s->avctx, AV_LOG_DEBUG, "=");
7bc9090a 1864 else
9b879566 1865 av_log(s->avctx, AV_LOG_DEBUG, " ");
7bc9090a 1866 }
9b879566 1867// av_log(s->avctx, AV_LOG_DEBUG, " ");
7bc9090a 1868 }
9b879566 1869 av_log(s->avctx, AV_LOG_DEBUG, "\n");
7bc9090a
MN
1870 }
1871 }
8d7ec294 1872
0c9bbaec 1873 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
db6e7795
MN
1874 const int shift= 1 + s->quarter_sample;
1875 int mb_y;
0c9bbaec 1876 uint8_t *ptr;
0c9bbaec 1877 int i;
0982834b 1878 int h_chroma_shift, v_chroma_shift;
4f8a8319
MN
1879 const int width = s->avctx->width;
1880 const int height= s->avctx->height;
650cec0c 1881 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
c6f9e821 1882 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
b846b231 1883 s->low_delay=0; //needed to see the vectors without trashing the buffers
0c9bbaec 1884
0982834b 1885 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
0c9bbaec 1886 for(i=0; i<3; i++){
4f8a8319 1887 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
0c9bbaec
WH
1888 pict->data[i]= s->visualization_buffer[i];
1889 }
1890 pict->type= FF_BUFFER_TYPE_COPY;
1891 ptr= pict->data[0];
db6e7795
MN
1892
1893 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1894 int mb_x;
1895 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1896 const int mb_index= mb_x + mb_y*s->mb_stride;
0c9bbaec
WH
1897 if((s->avctx->debug_mv) && pict->motion_val){
1898 int type;
1899 for(type=0; type<3; type++){
e96682e6 1900 int direction = 0;
0c9bbaec
WH
1901 switch (type) {
1902 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1903 continue;
1904 direction = 0;
1905 break;
1906 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1907 continue;
1908 direction = 0;
1909 break;
1910 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1911 continue;
1912 direction = 1;
1913 break;
1914 }
ae55b533
MN
1915 if(!USES_LIST(pict->mb_type[mb_index], direction))
1916 continue;
1917
0c9bbaec
WH
1918 if(IS_8X8(pict->mb_type[mb_index])){
1919 int i;
1920 for(i=0; i<4; i++){
db6e7795
MN
1921 int sx= mb_x*16 + 4 + 8*(i&1);
1922 int sy= mb_y*16 + 4 + 8*(i>>1);
88730be6 1923 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
0c9bbaec
WH
1924 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1925 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
4f8a8319 1926 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
0c9bbaec
WH
1927 }
1928 }else if(IS_16X8(pict->mb_type[mb_index])){
1929 int i;
1930 for(i=0; i<2; i++){
9bc8b386
MN
1931 int sx=mb_x*16 + 8;
1932 int sy=mb_y*16 + 4 + 8*i;
88730be6 1933 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
650cec0c
LM
1934 int mx=(pict->motion_val[direction][xy][0]>>shift);
1935 int my=(pict->motion_val[direction][xy][1]>>shift);
115329f1 1936
650cec0c
LM
1937 if(IS_INTERLACED(pict->mb_type[mb_index]))
1938 my*=2;
115329f1 1939
650cec0c
LM
1940 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1941 }
1942 }else if(IS_8X16(pict->mb_type[mb_index])){
1943 int i;
1944 for(i=0; i<2; i++){
1945 int sx=mb_x*16 + 4 + 8*i;
1946 int sy=mb_y*16 + 8;
88730be6 1947 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
38030214
MN
1948 int mx=(pict->motion_val[direction][xy][0]>>shift);
1949 int my=(pict->motion_val[direction][xy][1]>>shift);
115329f1 1950
38030214
MN
1951 if(IS_INTERLACED(pict->mb_type[mb_index]))
1952 my*=2;
115329f1 1953
4f8a8319 1954 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
0c9bbaec
WH
1955 }
1956 }else{
1957 int sx= mb_x*16 + 8;
1958 int sy= mb_y*16 + 8;
650cec0c 1959 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
0c9bbaec
WH
1960 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1961 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
4f8a8319 1962 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
9bc8b386 1963 }
115329f1 1964 }
864119b6
MN
1965 }
1966 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1967 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1968 int y;
1969 for(y=0; y<8; y++){
1970 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1971 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1972 }
1973 }
1974 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1975 int mb_type= pict->mb_type[mb_index];
1976 uint64_t u,v;
1977 int y;
1978#define COLOR(theta, r)\
1979u= (int)(128 + r*cos(theta*3.141592/180));\
1980v= (int)(128 + r*sin(theta*3.141592/180));
1981
115329f1 1982
864119b6
MN
1983 u=v=128;
1984 if(IS_PCM(mb_type)){
1985 COLOR(120,48)
1986 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1987 COLOR(30,48)
1988 }else if(IS_INTRA4x4(mb_type)){
1989 COLOR(90,48)
1990 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1991// COLOR(120,48)
1992 }else if(IS_DIRECT(mb_type)){
1993 COLOR(150,48)
1994 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1995 COLOR(170,48)
1996 }else if(IS_GMC(mb_type)){
1997 COLOR(190,48)
1998 }else if(IS_SKIP(mb_type)){
1999// COLOR(180,48)
2000 }else if(!USES_LIST(mb_type, 1)){
2001 COLOR(240,48)
2002 }else if(!USES_LIST(mb_type, 0)){
2003 COLOR(0,48)
2004 }else{
2005 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2006 COLOR(300,48)
2007 }
2008
2009 u*= 0x0101010101010101ULL;
2010 v*= 0x0101010101010101ULL;
2011 for(y=0; y<8; y++){
2012 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2013 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2014 }
2015
2016 //segmentation
2017 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
2018 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2019 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2020 }
2021 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2022 for(y=0; y<16; y++)
2023 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2024 }
e21f3983
LM
2025 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2026 int dm= 1 << (mv_sample_log2-2);
2027 for(i=0; i<4; i++){
2028 int sx= mb_x*16 + 8*(i&1);
2029 int sy= mb_y*16 + 8*(i>>1);
2030 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2031 //FIXME bidir
2032 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2033 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2034 for(y=0; y<8; y++)
2035 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2036 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2037 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2038 }
2039 }
115329f1 2040
864119b6
MN
2041 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2042 // hmm
2043 }
db6e7795
MN
2044 }
2045 s->mbskip_table[mb_index]=0;
2046 }
2047 }
2048 }
7bc9090a
MN
2049}
2050
7604246d
WH
2051#ifdef CONFIG_ENCODERS
2052
0d1e9246
MN
2053static int get_sae(uint8_t *src, int ref, int stride){
2054 int x,y;
2055 int acc=0;
115329f1 2056
0d1e9246
MN
2057 for(y=0; y<16; y++){
2058 for(x=0; x<16; x++){
c26abfa5 2059 acc+= FFABS(src[x+y*stride] - ref);
0d1e9246
MN
2060 }
2061 }
115329f1 2062
0d1e9246
MN
2063 return acc;
2064}
2065
2066static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2067 int x, y, w, h;
2068 int acc=0;
115329f1 2069
0d1e9246
MN
2070 w= s->width &~15;
2071 h= s->height&~15;
115329f1 2072
0d1e9246
MN
2073 for(y=0; y<h; y+=16){
2074 for(x=0; x<w; x+=16){
2075 int offset= x + y*stride;
bb198e19 2076 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
0d1e9246
MN
2077 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2078 int sae = get_sae(src + offset, mean, stride);
115329f1 2079
0d1e9246
MN
2080 acc+= sae + 500 < sad;
2081 }
2082 }
2083 return acc;
2084}
2085
4e00e76b 2086
492cd3a9 2087static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
17d71fb9 2088 AVFrame *pic=NULL;
30231f81 2089 int64_t pts;
4e00e76b 2090 int i;
1e491e29 2091 const int encoding_delay= s->max_b_frames;
4e00e76b 2092 int direct=1;
115329f1 2093
eaba7c7f 2094 if(pic_arg){
30231f81
MN
2095 pts= pic_arg->pts;
2096 pic_arg->display_picture_number= s->input_picture_number++;
2097
115329f1 2098 if(pts != AV_NOPTS_VALUE){
eaba7c7f 2099 if(s->user_specified_pts != AV_NOPTS_VALUE){
c0df9d75
MN
2100 int64_t time= pts;
2101 int64_t last= s->user_specified_pts;
115329f1
DB
2102
2103 if(time <= last){
4733abcb 2104 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
eaba7c7f
MN
2105 return -1;
2106 }
2107 }
30231f81 2108 s->user_specified_pts= pts;
eaba7c7f
MN
2109 }else{
2110 if(s->user_specified_pts != AV_NOPTS_VALUE){
115329f1 2111 s->user_specified_pts=
c0df9d75 2112 pts= s->user_specified_pts + 1;
4733abcb 2113 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
eaba7c7f 2114 }else{
c0df9d75 2115 pts= pic_arg->display_picture_number;
eaba7c7f
MN
2116 }
2117 }
2118 }
2119
17d71fb9 2120 if(pic_arg){
4e00e76b
MN
2121 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2122 if(pic_arg->linesize[0] != s->linesize) direct=0;
2123 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2124 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
115329f1 2125
9b879566 2126// av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
115329f1 2127
4e00e76b 2128 if(direct){
5f194811 2129 i= ff_find_unused_picture(s, 1);
1e491e29 2130
492cd3a9 2131 pic= (AVFrame*)&s->picture[i];
0da71265 2132 pic->reference= 3;
115329f1 2133
4e00e76b
MN
2134 for(i=0; i<4; i++){
2135 pic->data[i]= pic_arg->data[i];
2136 pic->linesize[i]= pic_arg->linesize[i];
2137 }
2138 alloc_picture(s, (Picture*)pic, 1);
2139 }else{
5f194811 2140 i= ff_find_unused_picture(s, 0);
1e491e29 2141
492cd3a9 2142 pic= (AVFrame*)&s->picture[i];
0da71265 2143 pic->reference= 3;
1e491e29 2144
4e00e76b
MN
2145 alloc_picture(s, (Picture*)pic, 0);
2146
07fc2b82
MN
2147 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2148 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2149 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
1e491e29 2150 // empty
4e00e76b
MN
2151 }else{
2152 int h_chroma_shift, v_chroma_shift;
4e00e76b 2153 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
115329f1 2154
4e00e76b
MN
2155 for(i=0; i<3; i++){
2156 int src_stride= pic_arg->linesize[i];
2157 int dst_stride= i ? s->uvlinesize : s->linesize;
2158 int h_shift= i ? h_chroma_shift : 0;
2159 int v_shift= i ? v_chroma_shift : 0;
2160 int w= s->width >>h_shift;
2161 int h= s->height>>v_shift;
2162 uint8_t *src= pic_arg->data[i];
07506002
MN
2163 uint8_t *dst= pic->data[i];
2164
2165 if(!s->avctx->rc_buffer_size)
2166 dst +=INPLACE_OFFSET;
115329f1 2167
4e00e76b
MN
2168 if(src_stride==dst_stride)
2169 memcpy(dst, src, src_stride*h);
2170 else{
2171 while(h--){
2172 memcpy(dst, src, w);
2173 dst += dst_stride;
2174 src += src_stride;
2175 }
1e491e29 2176 }
9dbcbd92 2177 }
1e491e29
MN
2178 }
2179 }
137c8468 2180 copy_picture_attributes(s, pic, pic_arg);
30231f81 2181 pic->pts= pts; //we set this here to avoid modifiying pic_arg
17d71fb9 2182 }
115329f1 2183
4e00e76b
MN
2184 /* shift buffer entries */
2185 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2186 s->input_picture[i-1]= s->input_picture[i];
115329f1 2187
4e00e76b 2188 s->input_picture[encoding_delay]= (Picture*)pic;
1e491e29
MN
2189
2190 return 0;
2191}
9dbcbd92 2192
bbf18b21
MN
2193static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2194 int x, y, plane;
2195 int score=0;
0fd6aea1 2196 int64_t score64=0;
bbf18b21
MN
2197
2198 for(plane=0; plane<3; plane++){
2199 const int stride= p->linesize[plane];
2200 const int bw= plane ? 1 : 2;
2201 for(y=0; y<s->mb_height*bw; y++){
2202 for(x=0; x<s->mb_width*bw; x++){
a75a3ca4
MN
2203 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2204 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
115329f1 2205
0fd6aea1
MN
2206 switch(s->avctx->frame_skip_exp){
2207 case 0: score= FFMAX(score, v); break;
c26abfa5 2208 case 1: score+= FFABS(v);break;
0fd6aea1 2209 case 2: score+= v*v;break;
c26abfa5 2210 case 3: score64+= FFABS(v*v*(int64_t)v);break;
0fd6aea1
MN
2211 case 4: score64+= v*v*(int64_t)(v*v);break;
2212 }
bbf18b21
MN
2213 }
2214 }
2215 }
115329f1 2216
0fd6aea1 2217 if(score) score64= score;
bbf18b21 2218
0fd6aea1 2219 if(score64 < s->avctx->frame_skip_threshold)
bbf18b21 2220 return 1;
0fd6aea1 2221 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
bbf18b21
MN
2222 return 1;
2223 return 0;
2224}
2225
984b8e4d
MN
2226static int estimate_best_b_count(MpegEncContext *s){
2227 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2228 AVCodecContext *c= avcodec_alloc_context();
2229 AVFrame input[FF_MAX_B_FRAMES+2];
e8501c93 2230 const int scale= s->avctx->brd_scale;
07fc2b82 2231 int i, j, out_size, p_lambda, b_lambda, lambda2;
e8501c93 2232 int outbuf_size= s->width * s->height; //FIXME
984b8e4d 2233 uint8_t *outbuf= av_malloc(outbuf_size);
984b8e4d
MN
2234 int64_t best_rd= INT64_MAX;
2235 int best_b_count= -1;
07fc2b82 2236
54009d42
MN
2237 assert(scale>=0 && scale <=3);
2238
07fc2b82
MN
2239// emms_c();
2240 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
c26abfa5 2241 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
07fc2b82
MN
2242 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2243 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
984b8e4d
MN
2244
2245 c->width = s->width >> scale;
2246 c->height= s->height>> scale;
2247 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2248 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2249 c->mb_decision= s->avctx->mb_decision;
2250 c->me_cmp= s->avctx->me_cmp;
2251 c->mb_cmp= s->avctx->mb_cmp;
2252 c->me_sub_cmp= s->avctx->me_sub_cmp;
2253 c->pix_fmt = PIX_FMT_YUV420P;
2254 c->time_base= s->avctx->time_base;
2255 c->max_b_frames= s->max_b_frames;
2256
2257 if (avcodec_open(c, codec) < 0)
2258 return -1;
2259
984b8e4d
MN
2260 for(i=0; i<s->max_b_frames+2; i++){
2261 int ysize= c->width*c->height;
2262 int csize= (c->width/2)*(c->height/2);
07fc2b82
MN
2263 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2264
984b8e4d
MN
2265 avcodec_get_frame_defaults(&input[i]);
2266 input[i].data[0]= av_malloc(ysize + 2*csize);
2267 input[i].data[1]= input[i].data[0] + ysize;
2268 input[i].data[2]= input[i].data[1] + csize;
2269 input[i].linesize[0]= c->width;
2270 input[i].linesize[1]=
2271 input[i].linesize[2]= c->width/2;
2272
994fd850
LB
2273 if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2274 pre_input= *pre_input_ptr;
2275
2276 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2277 pre_input.data[0]+=INPLACE_OFFSET;
2278 pre_input.data[1]+=INPLACE_OFFSET;
2279 pre_input.data[2]+=INPLACE_OFFSET;
2280 }
2281
54009d42
MN
2282 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2283 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2284 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2285 }
984b8e4d
MN
2286 }
2287
2288 for(j=0; j<s->max_b_frames+1; j++){
2289 int64_t rd=0;
2290
2291 if(!s->input_picture[j])
2292 break;
2293
2294 c->error[0]= c->error[1]= c->error[2]= 0;
2295
2296 input[0].pict_type= I_TYPE;
07fc2b82 2297 input[0].quality= 1 * FF_QP2LAMBDA;
984b8e4d 2298 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
07fc2b82 2299// rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
984b8e4d
MN
2300
2301 for(i=0; i<s->max_b_frames+1; i++){
2302 int is_p= i % (j+1) == j || i==s->max_b_frames;
2303
2304 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
07fc2b82 2305 input[i+1].quality= is_p ? p_lambda : b_lambda;
984b8e4d 2306 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
07fc2b82 2307 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
984b8e4d
MN
2308 }
2309
2310 /* get the delayed frames */
2311 while(out_size){
2312 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
07fc2b82 2313 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
984b8e4d
MN
2314 }
2315
2316 rd += c->error[0] + c->error[1] + c->error[2];
2317
2318 if(rd < best_rd){
2319 best_rd= rd;
2320 best_b_count= j;
2321 }
2322 }
2323
2324 av_freep(&outbuf);
2325 avcodec_close(c);
2326 av_freep(&c);
984b8e4d
MN
2327
2328 for(i=0; i<s->max_b_frames+2; i++){
2329 av_freep(&input[i].data[0]);
2330 }
2331
2332 return best_b_count;
2333}
2334
1e491e29
MN
2335static void select_input_picture(MpegEncContext *s){
2336 int i;
4e00e76b 2337
1e491e29
MN
2338 for(i=1; i<MAX_PICTURE_COUNT; i++)
2339 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2340 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2341
bb628dae 2342 /* set next picture type & ordering */
1e491e29 2343 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
b536d0aa 2344 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
0d1e9246
MN
2345 s->reordered_input_picture[0]= s->input_picture[0];
2346 s->reordered_input_picture[0]->pict_type= I_TYPE;
1031fabd 2347 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
0d1e9246
MN
2348 }else{
2349 int b_frames;
bbf18b21
MN
2350
2351 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
a75a3ca4
MN
2352 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2353 //FIXME check that te gop check above is +-1 correct
949b1a13 2354//av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
115329f1 2355
bbf18b21
MN
2356 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2357 for(i=0; i<4; i++)
2358 s->input_picture[0]->data[i]= NULL;
115329f1 2359 s->input_picture[0]->type= 0;
bbf18b21 2360 }else{
115329f1 2361 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
bbf18b21 2362 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
115329f1 2363
bbf18b21
MN
2364 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2365 }
115329f1 2366
a75a3ca4
MN
2367 emms_c();
2368 ff_vbv_update(s, 0);
bbf18b21
MN
2369
2370 goto no_output_pic;
2371 }
2372 }
2373
0d1e9246
MN
2374 if(s->flags&CODEC_FLAG_PASS2){
2375 for(i=0; i<s->max_b_frames+1; i++){
2376 int pict_num= s->input_picture[0]->display_picture_number + i;
80516d72 2377
115329f1 2378 if(pict_num >= s->rc_context.num_entries)
6db2583c 2379 break;
80516d72 2380 if(!s->input_picture[i]){
6db2583c 2381 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
80516d72
LM
2382 break;
2383 }
6db2583c 2384
115329f1 2385 s->input_picture[i]->pict_type=
6db2583c 2386 s->rc_context.entry[pict_num].new_pict_type;
0d1e9246
MN
2387 }
2388 }
4e00e76b 2389
9efc77c8 2390 if(s->avctx->b_frame_strategy==0){
0d1e9246 2391 b_frames= s->max_b_frames;
17d71fb9 2392 while(b_frames && !s->input_picture[b_frames]) b_frames--;
d55f7b65 2393 }else if(s->avctx->b_frame_strategy==1){
0d1e9246 2394 for(i=1; i<s->max_b_frames+1; i++){
17d71fb9 2395 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
115329f1
DB
2396 s->input_picture[i]->b_frame_score=
2397 get_intra_count(s, s->input_picture[i ]->data[0],
4e00e76b 2398 s->input_picture[i-1]->data[0], s->linesize) + 1;
0d1e9246
MN
2399 }
2400 }
ded8477d 2401 for(i=0; i<s->max_b_frames+1; i++){
f9243d34 2402 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
0d1e9246 2403 }
115329f1 2404
0d1e9246 2405 b_frames= FFMAX(0, i-1);
115329f1 2406
0d1e9246
MN
2407 /* reset scores */
2408 for(i=0; i<b_frames+1; i++){
2409 s->input_picture[i]->b_frame_score=0;
2410 }
984b8e4d
MN
2411 }else if(s->avctx->b_frame_strategy==2){
2412 b_frames= estimate_best_b_count(s);
0d1e9246 2413 }else{
9b879566 2414 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
0d1e9246 2415 b_frames=0;
140cb663 2416 }
0d1e9246
MN
2417
2418 emms_c();
2419//static int b_count=0;
2420//b_count+= b_frames;
9b879566 2421//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
9efc77c8
MN
2422
2423 for(i= b_frames - 1; i>=0; i--){
2424 int type= s->input_picture[i]->pict_type;
2425 if(type && type != B_TYPE)
2426 b_frames= i;
2427 }
2428 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
dfb706da 2429 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
9efc77c8
MN
2430 }
2431
303e50e6 2432 if(s->picture_in_gop_number + b_frames >= s->gop_size){
03581772
MN
2433 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2434 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2435 }else{
303e50e6
MN
2436 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2437 b_frames=0;
2438 s->input_picture[b_frames]->pict_type= I_TYPE;
03581772 2439 }
303e50e6 2440 }
115329f1 2441
303e50e6
MN
2442 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2443 && b_frames
2444 && s->input_picture[b_frames]->pict_type== I_TYPE)
2445 b_frames--;
2446
0d1e9246 2447 s->reordered_input_picture[0]= s->input_picture[b_frames];
303e50e6 2448 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
0d1e9246 2449 s->reordered_input_picture[0]->pict_type= P_TYPE;
1031fabd 2450 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
0d1e9246 2451 for(i=0; i<b_frames; i++){
0d1e9246
MN
2452 s->reordered_input_picture[i+1]= s->input_picture[i];
2453 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1031fabd 2454 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
9dbcbd92
MN
2455 }
2456 }
9dbcbd92 2457 }
bbf18b21 2458no_output_pic:
1e491e29 2459 if(s->reordered_input_picture[0]){
0da71265 2460 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
b536d0aa 2461
6571e41d 2462 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
4e00e76b 2463
07506002 2464 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
bb628dae 2465 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
115329f1 2466
5f194811 2467 int i= ff_find_unused_picture(s, 0);
4e00e76b
MN
2468 Picture *pic= &s->picture[i];
2469
07506002
MN
2470 pic->reference = s->reordered_input_picture[0]->reference;
2471 alloc_picture(s, pic, 0);
2472
4e00e76b 2473 /* mark us unused / free shared pic */
07506002
MN
2474 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2475 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
4e00e76b
MN
2476 for(i=0; i<4; i++)
2477 s->reordered_input_picture[0]->data[i]= NULL;
2478 s->reordered_input_picture[0]->type= 0;
115329f1 2479
f4f3223f
MN
2480 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2481
b536d0aa 2482 s->current_picture_ptr= pic;
4e00e76b 2483 }else{
b536d0aa
MN
2484 // input is not a shared pix -> reuse buffer for current_pix
2485
115329f1 2486 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
4e00e76b 2487 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
115329f1 2488
b536d0aa 2489 s->current_picture_ptr= s->reordered_input_picture[0];
4e00e76b 2490 for(i=0; i<4; i++){
07fc2b82 2491 s->new_picture.data[i]+= INPLACE_OFFSET;
4e00e76b 2492 }
1e491e29 2493 }
6571e41d 2494 copy_picture(&s->current_picture, s->current_picture_ptr);
115329f1 2495
1e491e29
MN
2496 s->picture_number= s->new_picture.display_picture_number;
2497//printf("dpn:%d\n", s->picture_number);
2498 }else{
2499 memset(&s->new_picture, 0, sizeof(Picture));
9dbcbd92
MN
2500 }
2501}
2502
de6d9b64
FB
2503int MPV_encode_picture(AVCodecContext *avctx,
2504 unsigned char *buf, int buf_size, void *data)
2505{
2506 MpegEncContext *s = avctx->priv_data;
492cd3a9 2507 AVFrame *pic_arg = data;
11dffbe1 2508 int i, stuffing_count;
de6d9b64 2509
9c3d33d6 2510 for(i=0; i<avctx->thread_count; i++){
259630df
MN
2511 int start_y= s->thread_context[i]->start_mb_y;
2512 int end_y= s->thread_context[i]-> end_mb_y;
9c3d33d6 2513 int h= s->mb_height;
acb22f93
MB
2514 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2515 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
9c3d33d6
MN
2516
2517 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2518 }
de6d9b64 2519
1e491e29 2520 s->picture_in_gop_number++;
de6d9b64 2521
9ebb8e11
MN
2522 if(load_input_picture(s, pic_arg) < 0)
2523 return -1;
115329f1 2524
1e491e29 2525 select_input_picture(s);
115329f1 2526
9dbcbd92 2527 /* output? */
1e491e29 2528 if(s->new_picture.data[0]){
1e491e29 2529 s->pict_type= s->new_picture.pict_type;
1e491e29
MN
2530//emms_c();
2531//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
93a21abd 2532 MPV_frame_start(s, avctx);
07506002 2533vbv_retry:
4156a436
PI
2534 if (encode_picture(s, s->picture_number) < 0)
2535 return -1;
115329f1 2536
9cd3766f 2537 avctx->real_pict_num = s->picture_number;
9dbcbd92
MN
2538 avctx->header_bits = s->header_bits;
2539 avctx->mv_bits = s->mv_bits;
2540 avctx->misc_bits = s->misc_bits;
2541 avctx->i_tex_bits = s->i_tex_bits;
2542 avctx->p_tex_bits = s->p_tex_bits;
2543 avctx->i_count = s->i_count;
66370d3f 2544 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
9dbcbd92
MN
2545 avctx->skip_count = s->skip_count;
2546
2547 MPV_frame_end(s);
2548
f6993c9f 2549 if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
44301eaa 2550 ff_mjpeg_encode_picture_trailer(s);
115329f1 2551
07506002
MN
2552 if(avctx->rc_buffer_size){
2553 RateControlContext *rcc= &s->rc_context;
2554 int max_size= rcc->buffer_index/3;
2555
ea7307df 2556 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
5dc49706 2557 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
ec9ed85d
MN
2558 if(s->adaptive_quant){
2559 int i;
169bc475 2560 for(i=0; i<s->mb_height*s->mb_stride; i++)
ec9ed85d
MN
2561 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
2562 }
07506002
MN
2563 s->mb_skipped = 0; //done in MPV_frame_start()
2564 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2565 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2566 s->no_rounding ^= 1;
2567 }
7aba9187
MN
2568 if(s->pict_type!=B_TYPE){
2569 s->time_base= s->last_time_base;
2570 s->last_non_b_time= s->time - s->pp_time;
2571 }
07506002
MN
2572// av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2573 for(i=0; i<avctx->thread_count; i++){
2574 PutBitContext *pb= &s->thread_context[i]->pb;
2575 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2576 }
2577 goto vbv_retry;
2578 }
2579
2580 assert(s->avctx->rc_max_rate);
2581 }
2582
8b4c7dbc
MN
2583 if(s->flags&CODEC_FLAG_PASS1)
2584 ff_write_pass1_stats(s);
b536d0aa
MN
2585
2586 for(i=0; i<4; i++){
60d76256 2587 s->current_picture_ptr->error[i]= s->current_picture.error[i];
b536d0aa
MN
2588 avctx->error[i] += s->current_picture_ptr->error[i];
2589 }
11dffbe1 2590
a9c3ff5b
MN
2591 if(s->flags&CODEC_FLAG_PASS1)
2592 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
11dffbe1 2593 flush_put_bits(&s->pb);
cfbd16df 2594 s->frame_bits = put_bits_count(&s->pb);
d60a8f85 2595
2c8b796f
MN
2596 stuffing_count= ff_vbv_update(s, s->frame_bits);
2597 if(stuffing_count){
0ecca7a4
MN
2598 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2599 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2600 return -1;
2601 }
2602
2c8b796f
MN
2603 switch(s->codec_id){
2604 case CODEC_ID_MPEG1VIDEO:
2605 case CODEC_ID_MPEG2VIDEO:
2606 while(stuffing_count--){
2607 put_bits(&s->pb, 8, 0);
2608 }
2609 break;
2610 case CODEC_ID_MPEG4:
2611 put_bits(&s->pb, 16, 0);
2612 put_bits(&s->pb, 16, 0x1C3);
2613 stuffing_count -= 4;
2614 while(stuffing_count--){
2615 put_bits(&s->pb, 8, 0xFF);
2616 }
2617 break;
2618 default:
2619 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2620 }
2621 flush_put_bits(&s->pb);
cfbd16df 2622 s->frame_bits = put_bits_count(&s->pb);
2c8b796f 2623 }
d60a8f85 2624
115329f1 2625 /* update mpeg1/2 vbv_delay for CBR */
b73afeac
MN
2626 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2627 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2c8b796f 2628 int vbv_delay;
d60a8f85 2629
2c8b796f 2630 assert(s->repeat_first_field==0);
115329f1 2631
2c8b796f
MN
2632 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2633 assert(vbv_delay < 0xFFFF);
2634
2635 s->vbv_delay_ptr[0] &= 0xF8;
2636 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2637 s->vbv_delay_ptr[1] = vbv_delay>>5;
2638 s->vbv_delay_ptr[2] &= 0x07;
2639 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2640 }
2641 s->total_bits += s->frame_bits;
2642 avctx->frame_bits = s->frame_bits;
2643 }else{
2644 assert((pbBufPtr(&s->pb) == s->pb.buf));
2645 s->frame_bits=0;
d60a8f85 2646 }
2c8b796f 2647 assert((s->frame_bits&7)==0);
115329f1 2648
11dffbe1 2649 return s->frame_bits/8;
de6d9b64
FB
2650}
2651
7604246d
WH
2652#endif //CONFIG_ENCODERS
2653
44eb4951 2654static inline void gmc1_motion(MpegEncContext *s,
0c1a9eda 2655 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
5ba326b5 2656 uint8_t **ref_picture)
44eb4951 2657{
0c1a9eda 2658 uint8_t *ptr;
0fd90455 2659 int offset, src_x, src_y, linesize, uvlinesize;
44eb4951 2660 int motion_x, motion_y;
54993774 2661 int emu=0;
44eb4951 2662
44eb4951
MN
2663 motion_x= s->sprite_offset[0][0];
2664 motion_y= s->sprite_offset[0][1];
2665 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2666 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2667 motion_x<<=(3-s->sprite_warping_accuracy);
2668 motion_y<<=(3-s->sprite_warping_accuracy);
f66e4f5f 2669 src_x = av_clip(src_x, -16, s->width);
44eb4951
MN
2670 if (src_x == s->width)
2671 motion_x =0;
f66e4f5f 2672 src_y = av_clip(src_y, -16, s->height);
44eb4951
MN
2673 if (src_y == s->height)
2674 motion_y =0;
073b013d 2675
44eb4951 2676 linesize = s->linesize;
0fd90455 2677 uvlinesize = s->uvlinesize;
115329f1 2678
5ba326b5 2679 ptr = ref_picture[0] + (src_y * linesize) + src_x;
44eb4951 2680
54993774 2681 if(s->flags&CODEC_FLAG_EMU_EDGE){
a573cc27
MN
2682 if( (unsigned)src_x >= s->h_edge_pos - 17
2683 || (unsigned)src_y >= s->v_edge_pos - 17){
c009df3f 2684 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
54993774 2685 ptr= s->edge_emu_buffer;
54993774
MN
2686 }
2687 }
115329f1 2688
073b013d 2689 if((motion_x|motion_y)&7){
eb4b3dd3
ZK
2690 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2691 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
073b013d
MN
2692 }else{
2693 int dxy;
115329f1 2694
073b013d
MN
2695 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2696 if (s->no_rounding){
bb270c08 2697 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
073b013d 2698 }else{
eb4b3dd3
ZK
2699 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2700 }
073b013d 2701 }
115329f1 2702
073b013d 2703 if(s->flags&CODEC_FLAG_GRAY) return;
44eb4951
MN
2704
2705 motion_x= s->sprite_offset[1][0];
2706 motion_y= s->sprite_offset[1][1];
2707 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2708 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2709 motion_x<<=(3-s->sprite_warping_accuracy);
2710 motion_y<<=(3-s->sprite_warping_accuracy);
f66e4f5f 2711 src_x = av_clip(src_x, -8, s->width>>1);
44eb4951
MN
2712 if (src_x == s->width>>1)
2713 motion_x =0;
f66e4f5f 2714 src_y = av_clip(src_y, -8, s->height>>1);
44eb4951
MN
2715 if (src_y == s->height>>1)
2716 motion_y =0;
2717
5ba326b5 2718 offset = (src_y * uvlinesize) + src_x;
44eb4951 2719 ptr = ref_picture[1] + offset;
741235eb 2720 if(s->flags&CODEC_FLAG_EMU_EDGE){
a573cc27
MN
2721 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2722 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
c009df3f 2723 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
741235eb
MN
2724 ptr= s->edge_emu_buffer;
2725 emu=1;
2726 }
54993774 2727 }
5ba326b5 2728 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
115329f1 2729
44eb4951 2730 ptr = ref_picture[2] + offset;
54993774 2731 if(emu){
c009df3f 2732 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
54993774
MN
2733 ptr= s->edge_emu_buffer;
2734 }
5ba326b5 2735 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
115329f1 2736
44eb4951
MN
2737 return;
2738}
2739
073b013d 2740static inline void gmc_motion(MpegEncContext *s,
0c1a9eda 2741 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
5ba326b5 2742 uint8_t **ref_picture)
073b013d 2743{
0c1a9eda 2744 uint8_t *ptr;
073b013d
MN
2745 int linesize, uvlinesize;
2746 const int a= s->sprite_warping_accuracy;
2747 int ox, oy;
2748
2749 linesize = s->linesize;
2750 uvlinesize = s->uvlinesize;
2751
5ba326b5 2752 ptr = ref_picture[0];
073b013d 2753
073b013d
MN
2754 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2755 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2756
eb4b3dd3 2757 s->dsp.gmc(dest_y, ptr, linesize, 16,
115329f1
DB
2758 ox,
2759 oy,
073b013d 2760 s->sprite_delta[0][0], s->sprite_delta[0][1],
115329f1 2761 s->sprite_delta[1][0], s->sprite_delta[1][1],
073b013d
MN
2762 a+1, (1<<(2*a+1)) - s->no_rounding,
2763 s->h_edge_pos, s->v_edge_pos);
eb4b3dd3 2764 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
115329f1
DB
2765 ox + s->sprite_delta[0][0]*8,
2766 oy + s->sprite_delta[1][0]*8,
073b013d 2767 s->sprite_delta[0][0], s->sprite_delta[0][1],
115329f1 2768 s->sprite_delta[1][0], s->sprite_delta[1][1],
073b013d
MN
2769 a+1, (1<<(2*a+1)) - s->no_rounding,
2770 s->h_edge_pos, s->v_edge_pos);
2771
2772 if(s->flags&CODEC_FLAG_GRAY) return;
2773
073b013d
MN
2774 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2775 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2776
5ba326b5 2777 ptr = ref_picture[1];
eb4b3dd3 2778 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
115329f1
DB
2779 ox,
2780 oy,
073b013d 2781 s->sprite_delta[0][0], s->sprite_delta[0][1],
115329f1 2782 s->sprite_delta[1][0], s->sprite_delta[1][1],
073b013d
MN
2783 a+1, (1<<(2*a+1)) - s->no_rounding,
2784 s->h_edge_pos>>1, s->v_edge_pos>>1);
115329f1 2785
5ba326b5 2786 ptr = ref_picture[2];
eb4b3dd3 2787 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
115329f1
DB
2788 ox,
2789 oy,
073b013d 2790 s->sprite_delta[0][0], s->sprite_delta[0][1],
115329f1 2791 s->sprite_delta[1][0], s->sprite_delta[1][1],
073b013d
MN
2792 a+1, (1<<(2*a+1)) - s->no_rounding,
2793 s->h_edge_pos>>1, s->v_edge_pos>>1);
2794}
2795
c009df3f
MN
2796/**
2797 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2798 * @param buf destination buffer
2799 * @param src source buffer
2800 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2801 * @param block_w width of block
2802 * @param block_h height of block
2803 * @param src_x x coordinate of the top left sample of the block in the source buffer
2804 * @param src_y y coordinate of the top left sample of the block in the source buffer
2805 * @param w width of the source buffer
2806 * @param h height of the source buffer
2807 */
115329f1 2808void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
93a21abd
MN
2809 int src_x, int src_y, int w, int h){
2810 int x, y;
2811 int start_y, start_x, end_y, end_x;
eb4b3dd3 2812
93a21abd
MN
2813 if(src_y>= h){
2814 src+= (h-1-src_y)*linesize;
2815 src_y=h-1;
225f9c44
MN
2816 }else if(src_y<=-block_h){
2817 src+= (1-block_h-src_y)*linesize;
2818 src_y=1-block_h;
93a21abd
MN
2819 }
2820 if(src_x>= w){
2821 src+= (w-1-src_x);
2822 src_x=w-1;
225f9c44
MN
2823 }else if(src_x<=-block_w){
2824 src+= (1-block_w-src_x);
2825 src_x=1-block_w;
93a21abd
MN
2826 }
2827
b8a78f41
MN
2828 start_y= FFMAX(0, -src_y);
2829 start_x= FFMAX(0, -src_x);
2830 end_y= FFMIN(block_h, h-src_y);
2831 end_x= FFMIN(block_w, w-src_x);
54993774 2832
93a21abd
MN
2833 // copy existing part
2834 for(y=start_y; y<end_y; y++){
2835 for(x=start_x; x<end_x; x++){
2836 buf[x + y*linesize]= src[x + y*linesize];
2837 }
2838 }
2839
2840 //top
2841 for(y=0; y<start_y; y++){
2842 for(x=start_x; x<end_x; x++){
2843 buf[x + y*linesize]= buf[x + start_y*linesize];
2844 }
2845 }
2846
2847 //bottom
2848 for(y=end_y; y<block_h; y++){
2849 for(x=start_x; x<end_x; x++){
2850 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2851 }
2852 }
115329f1 2853
93a21abd
MN
2854 for(y=0; y<block_h; y++){
2855 //left
2856 for(x=0; x<start_x; x++){
2857 buf[x + y*linesize]= buf[start_x + y*linesize];
2858 }
115329f1 2859
93a21abd
MN
2860 //right
2861 for(x=end_x; x<block_w; x++){
2862 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2863 }
2864 }
2865}
2866
115329f1 2867static inline int hpel_motion(MpegEncContext *s,
5ba326b5
MN
2868 uint8_t *dest, uint8_t *src,
2869 int field_based, int field_select,
f7190f73
MN
2870 int src_x, int src_y,
2871 int width, int height, int stride,
2872 int h_edge_pos, int v_edge_pos,
2873 int w, int h, op_pixels_func *pix_op,
2874 int motion_x, int motion_y)
2875{
2876 int dxy;
2877 int emu=0;
2878
2879 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2880 src_x += motion_x >> 1;
2881 src_y += motion_y >> 1;
115329f1 2882
f7190f73 2883 /* WARNING: do no forget half pels */
f66e4f5f 2884 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
f7190f73
MN
2885 if (src_x == width)
2886 dxy &= ~1;
f66e4f5f 2887 src_y = av_clip(src_y, -16, height);
f7190f73
MN
2888 if (src_y == height)
2889 dxy &= ~2;
2890 src += src_y * stride + src_x;
2891
2892 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2893 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2894 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
5ba326b5
MN
2895 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2896 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
f7190f73
MN
2897 src= s->edge_emu_buffer;
2898 emu=1;
2899 }
2900 }
5ba326b5
MN
2901 if(field_select)
2902 src += s->linesize;
f7190f73
MN
2903 pix_op[dxy](dest, src, stride, h);
2904 return emu;
2905}
93a21abd 2906
115329f1 2907static inline int hpel_motion_lowres(MpegEncContext *s,
ac8b03c0
MN
2908 uint8_t *dest, uint8_t *src,
2909 int field_based, int field_select,
2910 int src_x, int src_y,
2911 int width, int height, int stride,
2912 int h_edge_pos, int v_edge_pos,
2913 int w, int h, h264_chroma_mc_func *pix_op,
2914 int motion_x, int motion_y)
2915{
2916 const int lowres= s->avctx->lowres;
2917 const int s_mask= (2<<lowres)-1;
2918 int emu=0;
2919 int sx, sy;
2920
2921 if(s->quarter_sample){
2922 motion_x/=2;
2923 motion_y/=2;
2924 }
2925
2926 sx= motion_x & s_mask;
2927 sy= motion_y & s_mask;
2928 src_x += motion_x >> (lowres+1);
2929 src_y += motion_y >> (lowres+1);
115329f1 2930
ac8b03c0
MN
2931 src += src_y * stride + src_x;
2932
2933 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2934 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2935 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2936 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2937 src= s->edge_emu_buffer;
2938 emu=1;
2939 }
2940
2941 sx <<= 2 - lowres;
2942 sy <<= 2 - lowres;
2943 if(field_select)
2944 src += s->linesize;
2945 pix_op[lowres](dest, src, stride, h, sx, sy);
2946 return emu;
2947}
2948
de6d9b64 2949/* apply one mpeg motion vector to the three components */
849f1035 2950static av_always_inline void mpeg_motion(MpegEncContext *s,
0c1a9eda 2951 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
5ba326b5
MN
2952 int field_based, int bottom_field, int field_select,
2953 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
de6d9b64
FB
2954 int motion_x, int motion_y, int h)
2955{
95d356c5
MN
2956 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2957 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
115329f1
DB
2958
2959#if 0
44eb4951
MN
2960if(s->quarter_sample)
2961{
2962 motion_x>>=1;
2963 motion_y>>=1;
2964}
b3184779 2965#endif
f7190f73 2966
b5a093b3 2967 v_edge_pos = s->v_edge_pos >> field_based;
95d356c5 2968 linesize = s->current_picture.linesize[0] << field_based;
b536d0aa 2969 uvlinesize = s->current_picture.linesize[1] << field_based;
93a21abd 2970
95d356c5
MN
2971 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2972 src_x = s->mb_x* 16 + (motion_x >> 1);
ffdff4d7 2973 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
b50eef3a 2974
de6d9b64 2975 if (s->out_format == FMT_H263) {
b44bdf7e
MN
2976 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2977 mx = (motion_x>>1)|(motion_x&1);
2978 my = motion_y >>1;
2979 uvdxy = ((my & 1) << 1) | (mx & 1);
2980 uvsrc_x = s->mb_x* 8 + (mx >> 1);
ffdff4d7 2981 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
b44bdf7e
MN
2982 }else{
2983 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2984 uvsrc_x = src_x>>1;
2985 uvsrc_y = src_y>>1;
2986 }
c6148de2
MN
2987 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2988 mx = motion_x / 4;
2989 my = motion_y / 4;
2990 uvdxy = 0;
2991 uvsrc_x = s->mb_x*8 + mx;
2992 uvsrc_y = s->mb_y*8 + my;
de6d9b64 2993 } else {
ffdff4d7
IK
2994 if(s->chroma_y_shift){
2995 mx = motion_x / 2;
2996 my = motion_y / 2;
2997 uvdxy = ((my & 1) << 1) | (mx & 1);
2998 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2999 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
3000 } else {
3001 if(s->chroma_x_shift){
3002 //Chroma422
3003 mx = motion_x / 2;
3004 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
3005 uvsrc_x = s->mb_x* 8 + (mx >> 1);
3006 uvsrc_y = src_y;
3007 } else {
3008 //Chroma444
3009 uvdxy = dxy;
3010 uvsrc_x = src_x;
3011 uvsrc_y = src_y;
3012 }
3013 }
de6d9b64 3014 }
95d356c5
MN
3015
3016 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3017 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3018 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3019
3020 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
3021 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
ffdff4d7
IK
3022 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3023 s->codec_id == CODEC_ID_MPEG1VIDEO){
3024 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3025 return ;
3026 }
95d356c5
MN
3027 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,