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