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