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