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