mpegvideo.c@ 7692

Last change on this file since 7692 was 5776, checked in by vboxsync, 17 years ago
ffmpeg: exported to OSE
File size: 246.2 KB

Line
1	/*
2	* The simplest mpeg encoder (well, it was the simplest!)
3	* Copyright (c) 2000,2001 Fabrice Bellard.
4	* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5	*
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.
10	*
11	* This library is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19	*
20	* 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21	*/
22
23	/**
24	* @file mpegvideo.c
25	* The simplest mpeg encoder (well, it was the simplest!).
26	*/
27
28	#include "avcodec.h"
29	#include "dsputil.h"
30	#include "mpegvideo.h"
31	#include "faandct.h"
32	#include <limits.h>
33
34	#ifdef USE_FASTMEMCPY
35	#include "fastmemcpy.h"
36	#endif
37
38	//#undef NDEBUG
39	//#include <assert.h>
40
41	#ifdef CONFIG_ENCODERS
42	static void encode_picture(MpegEncContext *s, int picture_number);
43	#endif //CONFIG_ENCODERS
44	static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45	DCTELEM *block, int n, int qscale);
46	static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47	DCTELEM *block, int n, int qscale);
48	static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49	DCTELEM *block, int n, int qscale);
50	static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
51	DCTELEM *block, int n, int qscale);
52	static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53	DCTELEM *block, int n, int qscale);
54	static void dct_unquantize_h263_intra_c(MpegEncContext *s,
55	DCTELEM *block, int n, int qscale);
56	static void dct_unquantize_h263_inter_c(MpegEncContext *s,
57	DCTELEM *block, int n, int qscale);
58	static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
59	#ifdef CONFIG_ENCODERS
60	static int dct_quantize_c(MpegEncContext s, DCTELEM block, int n, int qscale, int *overflow);
61	static int dct_quantize_trellis_c(MpegEncContext s, DCTELEM block, int n, int qscale, int *overflow);
62	static int dct_quantize_refine(MpegEncContext s, DCTELEM block, int16_t weight, DCTELEM orig, int n, int qscale);
63	static int sse_mb(MpegEncContext *s);
64	static void denoise_dct_c(MpegEncContext s, DCTELEM block);
65	#endif //CONFIG_ENCODERS
66
67	#ifdef HAVE_XVMC
68	extern int XVMC_field_start(MpegEncContexts, AVCodecContext avctx);
69	extern void XVMC_field_end(MpegEncContext *s);
70	extern void XVMC_decode_mb(MpegEncContext *s);
71	#endif
72
73	void (draw_edges)(uint8_t buf, int wrap, int width, int height, int w)= draw_edges_c;
74
75
76	/* enable all paranoid tests for rounding, overflows, etc... */
77	//#define PARANOID
78
79	//#define DEBUG
80
81
82	/* for jpeg fast DCT */
83	#define CONST_BITS 14
84
85	static const uint16_t aanscales[64] = {
86	/* precomputed values scaled up by 14 bits */
87	16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
88	22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
89	21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
90	19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
91	16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
92	12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
93	8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
94	4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
95	};
96
97	static const uint8_t h263_chroma_roundtab[16] = {
98	// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
99	0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
100	};
101
102	static const uint8_t ff_default_chroma_qscale_table[32]={
103	// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
104	0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
105	};
106
107	#ifdef CONFIG_ENCODERS
108	static uint8_t (default_mv_penalty)[MAX_MV2+1]=NULL;
109	static uint8_t default_fcode_tab[MAX_MV*2+1];
110
111	enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
112
113	static void convert_matrix(DSPContext dsp, int (qmat)[64], uint16_t (*qmat16)[2][64],
114	const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
115	{
116	int qscale;
117	int shift=0;
118
119	for(qscale=qmin; qscale<=qmax; qscale++){
120	int i;
121	if (dsp->fdct == ff_jpeg_fdct_islow
122	#ifdef FAAN_POSTSCALE
123	\|\| dsp->fdct == ff_faandct
124	#endif
125	) {
126	for(i=0;i<64;i++) {
127	const int j= dsp->idct_permutation[i];
128	/* 16 <= qscale * quant_matrix[i] <= 7905 */
129	/* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
130	/* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
131	/* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
132
133	qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
134	(qscale * quant_matrix[j]));
135	}
136	} else if (dsp->fdct == fdct_ifast
137	#ifndef FAAN_POSTSCALE
138	\|\| dsp->fdct == ff_faandct
139	#endif
140	) {
141	for(i=0;i<64;i++) {
142	const int j= dsp->idct_permutation[i];
143	/* 16 <= qscale * quant_matrix[i] <= 7905 */
144	/* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
145	/* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
146	/* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
147
148	qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
149	(aanscales[i] * qscale * quant_matrix[j]));
150	}
151	} else {
152	for(i=0;i<64;i++) {
153	const int j= dsp->idct_permutation[i];
154	/* We can safely suppose that 16 <= quant_matrix[i] <= 255
155	So 16 <= qscale * quant_matrix[i] <= 7905
156	so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
157	so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
158	*/
159	qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
160	// qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
161	qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
162
163	if(qmat16[qscale][0][i]==0 \|\| qmat16[qscale][0][i]==128256) qmat16[qscale][0][i]=128256-1;
164	qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
165	}
166	}
167
168	for(i=intra; i<64; i++){
169	int64_t max= 8191;
170	if (dsp->fdct == fdct_ifast
171	#ifndef FAAN_POSTSCALE
172	\|\| dsp->fdct == ff_faandct
173	#endif
174	) {
175	max= (8191LL*aanscales[i]) >> 14;
176	}
177	while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
178	shift++;
179	}
180	}
181	}
182	if(shift){
183	av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
184	}
185	}
186
187	static inline void update_qscale(MpegEncContext *s){
188	s->qscale= (s->lambda139 + FF_LAMBDA_SCALE64) >> (FF_LAMBDA_SHIFT + 7);
189	s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
190
191	s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
192	}
193	#endif //CONFIG_ENCODERS
194
195	void ff_init_scantable(uint8_t permutation, ScanTable st, const uint8_t *src_scantable){
196	int i;
197	int end;
198
199	st->scantable= src_scantable;
200
201	for(i=0; i<64; i++){
202	int j;
203	j = src_scantable[i];
204	st->permutated[i] = permutation[j];
205	#ifdef ARCH_POWERPC
206	st->inverse[j] = i;
207	#endif
208	}
209
210	end=-1;
211	for(i=0; i<64; i++){
212	int j;
213	j = st->permutated[i];
214	if(j>end) end=j;
215	st->raster_end[i]= end;
216	}
217	}
218
219	#ifdef CONFIG_ENCODERS
220	void ff_write_quant_matrix(PutBitContext pb, int16_t matrix){
221	int i;
222
223	if(matrix){
224	put_bits(pb, 1, 1);
225	for(i=0;i<64;i++) {
226	put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
227	}
228	}else
229	put_bits(pb, 1, 0);
230	}
231	#endif //CONFIG_ENCODERS
232
233	const uint8_t ff_find_start_code(const uint8_t restrict p, const uint8_t end, uint32_t restrict state){
234	int i;
235
236	assert(p<=end);
237	if(p>=end)
238	return end;
239
240	for(i=0; i<3; i++){
241	uint32_t tmp= *state << 8;
242	state= tmp + (p++);
243	if(tmp == 0x100 \|\| p==end)
244	return p;
245	}
246
247	while(p<end){
248	if (p[-1] > 1 ) p+= 3;
249	else if(p[-2] ) p+= 2;
250	else if(p[-3]\|(p[-1]-1)) p++;
251	else{
252	p++;
253	break;
254	}
255	}
256
257	p= FFMIN(p, end)-4;
258	*state= be2me_32(unaligned32(p));
259
260	return p+4;
261	}
262
263	/* init common dct for both encoder and decoder */
264	int DCT_common_init(MpegEncContext *s)
265	{
266	s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
267	s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
268	s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
269	s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
270	s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
271	if(s->flags & CODEC_FLAG_BITEXACT)
272	s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
273	s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
274
275	#ifdef CONFIG_ENCODERS
276	s->dct_quantize= dct_quantize_c;
277	s->denoise_dct= denoise_dct_c;
278	#endif //CONFIG_ENCODERS
279
280	#ifdef HAVE_MMX
281	MPV_common_init_mmx(s);
282	#endif
283	#ifdef ARCH_ALPHA
284	MPV_common_init_axp(s);
285	#endif
286	#ifdef HAVE_MLIB
287	MPV_common_init_mlib(s);
288	#endif
289	#ifdef HAVE_MMI
290	MPV_common_init_mmi(s);
291	#endif
292	#ifdef ARCH_ARMV4L
293	MPV_common_init_armv4l(s);
294	#endif
295	#ifdef ARCH_POWERPC
296	MPV_common_init_ppc(s);
297	#endif
298
299	#ifdef CONFIG_ENCODERS
300	s->fast_dct_quantize= s->dct_quantize;
301
302	if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
303	s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
304	}
305
306	#endif //CONFIG_ENCODERS
307
308	/* load & permutate scantables
309	note: only wmv uses different ones
310	*/
311	if(s->alternate_scan){
312	ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
313	ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
314	}else{
315	ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
316	ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
317	}
318	ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
319	ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
320
321	return 0;
322	}
323
324	static void copy_picture(Picture dst, Picture src){
325	dst = src;
326	dst->type= FF_BUFFER_TYPE_COPY;
327	}
328
329	static void copy_picture_attributes(MpegEncContext s, AVFrame dst, AVFrame *src){
330	int i;
331
332	dst->pict_type = src->pict_type;
333	dst->quality = src->quality;
334	dst->coded_picture_number = src->coded_picture_number;
335	dst->display_picture_number = src->display_picture_number;
336	// dst->reference = src->reference;
337	dst->pts = src->pts;
338	dst->interlaced_frame = src->interlaced_frame;
339	dst->top_field_first = src->top_field_first;
340
341	if(s->avctx->me_threshold){
342	if(!src->motion_val[0])
343	av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
344	if(!src->mb_type)
345	av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
346	if(!src->ref_index[0])
347	av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
348	if(src->motion_subsample_log2 != dst->motion_subsample_log2)
349	av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
350	src->motion_subsample_log2, dst->motion_subsample_log2);
351
352	memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
353
354	for(i=0; i<2; i++){
355	int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
356	int height= ((16*s->mb_height)>>src->motion_subsample_log2);
357
358	if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
359	memcpy(dst->motion_val[i], src->motion_val[i], 2strideheight*sizeof(int16_t));
360	}
361	if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
362	memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride2s->mb_height*sizeof(int8_t));
363	}
364	}
365	}
366	}
367
368	/**
369	* allocates a Picture
370	* The pixels are allocated/set by calling get_buffer() if shared=0
371	*/
372	static int alloc_picture(MpegEncContext s, Picture pic, int shared){
373	const int big_mb_num= s->mb_stride(s->mb_height+1) + 1; //the +1 is needed so memset(,,strideheight) doesnt sig11
374	const int mb_array_size= s->mb_stride*s->mb_height;
375	const int b8_array_size= s->b8_strides->mb_height2;
376	const int b4_array_size= s->b4_strides->mb_height4;
377	int i;
378
379	if(shared){
380	assert(pic->data[0]);
381	assert(pic->type == 0 \|\| pic->type == FF_BUFFER_TYPE_SHARED);
382	pic->type= FF_BUFFER_TYPE_SHARED;
383	}else{
384	int r;
385
386	assert(!pic->data[0]);
387
388	r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
389
390	if(r<0 \|\| !pic->age \|\| !pic->type \|\| !pic->data[0]){
391	av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
392	return -1;
393	}
394
395	if(s->linesize && (s->linesize != pic->linesize[0] \|\| s->uvlinesize != pic->linesize[1])){
396	av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
397	return -1;
398	}
399
400	if(pic->linesize[1] != pic->linesize[2]){
401	av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
402	return -1;
403	}
404
405	s->linesize = pic->linesize[0];
406	s->uvlinesize= pic->linesize[1];
407	}
408
409	if(pic->qscale_table==NULL){
410	if (s->encoding) {
411	CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
412	CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
413	CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
414	}
415
416	CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
417	CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
418	CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
419	pic->mb_type= pic->mb_type_base + s->mb_stride+1;
420	if(s->out_format == FMT_H264){
421	for(i=0; i<2; i++){
422	CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
423	pic->motion_val[i]= pic->motion_val_base[i]+4;
424	CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
425	}
426	pic->motion_subsample_log2= 2;
427	}else if(s->out_format == FMT_H263 \|\| s->encoding \|\| (s->avctx->debug&FF_DEBUG_MV) \|\| (s->avctx->debug_mv)){
428	for(i=0; i<2; i++){
429	CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
430	pic->motion_val[i]= pic->motion_val_base[i]+4;
431	CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
432	}
433	pic->motion_subsample_log2= 3;
434	}
435	if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
436	CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
437	}
438	pic->qstride= s->mb_stride;
439	CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
440	}
441
442	//it might be nicer if the application would keep track of these but it would require a API change
443	memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
444	s->prev_pict_types[0]= s->pict_type;
445	if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
446	pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
447
448	return 0;
449	fail: //for the CHECKED_ALLOCZ macro
450	return -1;
451	}
452
453	/**
454	* deallocates a picture
455	*/
456	static void free_picture(MpegEncContext s, Picture pic){
457	int i;
458
459	if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
460	s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
461	}
462
463	av_freep(&pic->mb_var);
464	av_freep(&pic->mc_mb_var);
465	av_freep(&pic->mb_mean);
466	av_freep(&pic->mbskip_table);
467	av_freep(&pic->qscale_table);
468	av_freep(&pic->mb_type_base);
469	av_freep(&pic->dct_coeff);
470	av_freep(&pic->pan_scan);
471	pic->mb_type= NULL;
472	for(i=0; i<2; i++){
473	av_freep(&pic->motion_val_base[i]);
474	av_freep(&pic->ref_index[i]);
475	}
476
477	if(pic->type == FF_BUFFER_TYPE_SHARED){
478	for(i=0; i<4; i++){
479	pic->base[i]=
480	pic->data[i]= NULL;
481	}
482	pic->type= 0;
483	}
484	}
485
486	static int init_duplicate_context(MpegEncContext s, MpegEncContext base){
487	int i;
488
489	// edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
490	CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)2212); //(width + edge + align)interlacedMBsizetolerance
491	s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)221;
492
493	//FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
494	CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)4162sizeof(uint8_t))
495	s->rd_scratchpad= s->me.scratchpad;
496	s->b_scratchpad= s->me.scratchpad;
497	s->obmc_scratchpad= s->me.scratchpad + 16;
498	if (s->encoding) {
499	CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
500	CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
501	if(s->avctx->noise_reduction){
502	CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
503	}
504	}
505	CHECKED_ALLOCZ(s->blocks, 64122 * sizeof(DCTELEM))
506	s->block= s->blocks[0];
507
508	for(i=0;i<12;i++){
509	s->pblocks[i] = (short *)(&s->block[i]);
510	}
511	return 0;
512	fail:
513	return -1; //free() through MPV_common_end()
514	}
515
516	static void free_duplicate_context(MpegEncContext *s){
517	if(s==NULL) return;
518
519	av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
520	av_freep(&s->me.scratchpad);
521	s->rd_scratchpad=
522	s->b_scratchpad=
523	s->obmc_scratchpad= NULL;
524
525	av_freep(&s->dct_error_sum);
526	av_freep(&s->me.map);
527	av_freep(&s->me.score_map);
528	av_freep(&s->blocks);
529	s->block= NULL;
530	}
531
532	static void backup_duplicate_context(MpegEncContext bak, MpegEncContext src){
533	#define COPY(a) bak->a= src->a
534	COPY(allocated_edge_emu_buffer);
535	COPY(edge_emu_buffer);
536	COPY(me.scratchpad);
537	COPY(rd_scratchpad);
538	COPY(b_scratchpad);
539	COPY(obmc_scratchpad);
540	COPY(me.map);
541	COPY(me.score_map);
542	COPY(blocks);
543	COPY(block);
544	COPY(start_mb_y);
545	COPY(end_mb_y);
546	COPY(me.map_generation);
547	COPY(pb);
548	COPY(dct_error_sum);
549	COPY(dct_count[0]);
550	COPY(dct_count[1]);
551	#undef COPY
552	}
553
554	void ff_update_duplicate_context(MpegEncContext dst, MpegEncContext src){
555	MpegEncContext bak;
556	int i;
557	//FIXME copy only needed parts
558	//START_TIMER
559	backup_duplicate_context(&bak, dst);
560	memcpy(dst, src, sizeof(MpegEncContext));
561	backup_duplicate_context(dst, &bak);
562	for(i=0;i<12;i++){
563	dst->pblocks[i] = (short *)(&dst->block[i]);
564	}
565	//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
566	}
567
568	static void update_duplicate_context_after_me(MpegEncContext dst, MpegEncContext src){
569	#define COPY(a) dst->a= src->a
570	COPY(pict_type);
571	COPY(current_picture);
572	COPY(f_code);
573	COPY(b_code);
574	COPY(qscale);
575	COPY(lambda);
576	COPY(lambda2);
577	COPY(picture_in_gop_number);
578	COPY(gop_picture_number);
579	COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
580	COPY(progressive_frame); //FIXME don't set in encode_header
581	COPY(partitioned_frame); //FIXME don't set in encode_header
582	#undef COPY
583	}
584
585	/**
586	* sets the given MpegEncContext to common defaults (same for encoding and decoding).
587	* the changed fields will not depend upon the prior state of the MpegEncContext.
588	*/
589	static void MPV_common_defaults(MpegEncContext *s){
590	s->y_dc_scale_table=
591	s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
592	s->chroma_qscale_table= ff_default_chroma_qscale_table;
593	s->progressive_frame= 1;
594	s->progressive_sequence= 1;
595	s->picture_structure= PICT_FRAME;
596
597	s->coded_picture_number = 0;
598	s->picture_number = 0;
599	s->input_picture_number = 0;
600
601	s->picture_in_gop_number = 0;
602
603	s->f_code = 1;
604	s->b_code = 1;
605	}
606
607	/**
608	* sets the given MpegEncContext to defaults for decoding.
609	* the changed fields will not depend upon the prior state of the MpegEncContext.
610	*/
611	void MPV_decode_defaults(MpegEncContext *s){
612	MPV_common_defaults(s);
613	}
614
615	/**
616	* sets the given MpegEncContext to defaults for encoding.
617	* the changed fields will not depend upon the prior state of the MpegEncContext.
618	*/
619
620	#ifdef CONFIG_ENCODERS
621	static void MPV_encode_defaults(MpegEncContext *s){
622	static int done=0;
623
624	MPV_common_defaults(s);
625
626	if(!done){
627	int i;
628	done=1;
629
630	default_mv_penalty= av_mallocz( sizeof(uint8_t)(MAX_FCODE+1)(2*MAX_MV+1) );
631	memset(default_fcode_tab , 0, sizeof(uint8_t)(2MAX_MV+1));
632
633	for(i=-16; i<16; i++){
634	default_fcode_tab[i + MAX_MV]= 1;
635	}
636	}
637	s->me.mv_penalty= default_mv_penalty;
638	s->fcode_tab= default_fcode_tab;
639	}
640	#endif //CONFIG_ENCODERS
641
642	/**
643	* init common structure for both encoder and decoder.
644	* this assumes that some variables like width/height are already set
645	*/
646	int MPV_common_init(MpegEncContext *s)
647	{
648	int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
649
650	s->mb_height = (s->height + 15) / 16;
651
652	if(s->avctx->thread_count > MAX_THREADS \|\| (s->avctx->thread_count > s->mb_height && s->mb_height)){
653	av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
654	return -1;
655	}
656
657	if((s->width \|\| s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
658	return -1;
659
660	dsputil_init(&s->dsp, s->avctx);
661	DCT_common_init(s);
662
663	s->flags= s->avctx->flags;
664	s->flags2= s->avctx->flags2;
665
666	s->mb_width = (s->width + 15) / 16;
667	s->mb_stride = s->mb_width + 1;
668	s->b8_stride = s->mb_width*2 + 1;
669	s->b4_stride = s->mb_width*4 + 1;
670	mb_array_size= s->mb_height * s->mb_stride;
671	mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
672
673	/* set chroma shifts */
674	avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
675	&(s->chroma_y_shift) );
676
677	/* set default edge pos, will be overriden in decode_header if needed */
678	s->h_edge_pos= s->mb_width*16;
679	s->v_edge_pos= s->mb_height*16;
680
681	s->mb_num = s->mb_width * s->mb_height;
682
683	s->block_wrap[0]=
684	s->block_wrap[1]=
685	s->block_wrap[2]=
686	s->block_wrap[3]= s->b8_stride;
687	s->block_wrap[4]=
688	s->block_wrap[5]= s->mb_stride;
689
690	y_size = s->b8_stride * (2 * s->mb_height + 1);
691	c_size = s->mb_stride * (s->mb_height + 1);
692	yc_size = y_size + 2 * c_size;
693
694	/* convert fourcc to upper case */
695	s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
696	+ (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
697	+ (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
698	+ (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
699
700	s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
701	+ (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
702	+ (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
703	+ (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
704
705	s->avctx->coded_frame= (AVFrame*)&s->current_picture;
706
707	CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
708	for(y=0; y<s->mb_height; y++){
709	for(x=0; x<s->mb_width; x++){
710	s->mb_index2xy[ x + ys->mb_width ] = x + ys->mb_stride;
711	}
712	}
713	s->mb_index2xy[ s->mb_heights->mb_width ] = (s->mb_height-1)s->mb_stride + s->mb_width; //FIXME really needed?
714
715	if (s->encoding) {
716	/* Allocate MV tables */
717	CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
718	CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
719	CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
720	CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
721	CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
722	CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
723	s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
724	s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
725	s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
726	s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
727	s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
728	s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
729
730	if(s->msmpeg4_version){
731	CHECKED_ALLOCZ(s->ac_stats, 22(MAX_LEVEL+1)(MAX_RUN+1)2*sizeof(int));
732	}
733	CHECKED_ALLOCZ(s->avctx->stats_out, 256);
734
735	/* Allocate MB type table */
736	CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
737
738	CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
739
740	CHECKED_ALLOCZ(s->q_intra_matrix, 6432 sizeof(int))
741	CHECKED_ALLOCZ(s->q_inter_matrix, 6432 sizeof(int))
742	CHECKED_ALLOCZ(s->q_intra_matrix16, 64322 * sizeof(uint16_t))
743	CHECKED_ALLOCZ(s->q_inter_matrix16, 64322 * sizeof(uint16_t))
744	CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
745	CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
746
747	if(s->avctx->noise_reduction){
748	CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
749	}
750	}
751	CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
752
753	CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
754
755	if(s->codec_id==CODEC_ID_MPEG4 \|\| (s->flags & CODEC_FLAG_INTERLACED_ME)){
756	/* interlaced direct mode decoding tables */
757	for(i=0; i<2; i++){
758	int j, k;
759	for(j=0; j<2; j++){
760	for(k=0; k<2; k++){
761	CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
762	s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
763	}
764	CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
765	CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
766	s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
767	}
768	CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
769	}
770	}
771	if (s->out_format == FMT_H263) {
772	/* ac values */
773	CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
774	s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
775	s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
776	s->ac_val[2] = s->ac_val[1] + c_size;
777
778	/* cbp values */
779	CHECKED_ALLOCZ(s->coded_block_base, y_size);
780	s->coded_block= s->coded_block_base + s->b8_stride + 1;
781
782	/* cbp, ac_pred, pred_dir */
783	CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
784	CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
785	}
786
787	if (s->h263_pred \|\| s->h263_plus \|\| !s->encoding) {
788	/* dc values */
789	//MN: we need these for error resilience of intra-frames
790	CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
791	s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
792	s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
793	s->dc_val[2] = s->dc_val[1] + c_size;
794	for(i=0;i<yc_size;i++)
795	s->dc_val_base[i] = 1024;
796	}
797
798	/* which mb is a intra block */
799	CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
800	memset(s->mbintra_table, 1, mb_array_size);
801
802	/* init macroblock skip table */
803	CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
804	//Note the +1 is for a quicker mpeg4 slice_end detection
805	CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
806
807	s->parse_context.state= -1;
808	if((s->avctx->debug&(FF_DEBUG_VIS_QP\|FF_DEBUG_VIS_MB_TYPE)) \|\| (s->avctx->debug_mv)){
809	s->visualization_buffer[0] = av_malloc((s->mb_width16 + 2EDGE_WIDTH) * s->mb_height16 + 2EDGE_WIDTH);
810	s->visualization_buffer[1] = av_malloc((s->mb_width8 + EDGE_WIDTH) s->mb_height*8 + EDGE_WIDTH);
811	s->visualization_buffer[2] = av_malloc((s->mb_width8 + EDGE_WIDTH) s->mb_height*8 + EDGE_WIDTH);
812	}
813
814	s->context_initialized = 1;
815
816	s->thread_context[0]= s;
817	for(i=1; i<s->avctx->thread_count; i++){
818	s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
819	memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
820	}
821
822	for(i=0; i<s->avctx->thread_count; i++){
823	if(init_duplicate_context(s->thread_context[i], s) < 0)
824	goto fail;
825	s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
826	s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
827	}
828
829	return 0;
830	fail:
831	MPV_common_end(s);
832	return -1;
833	}
834
835	/* init common structure for both encoder and decoder */
836	void MPV_common_end(MpegEncContext *s)
837	{
838	int i, j, k;
839
840	for(i=0; i<s->avctx->thread_count; i++){
841	free_duplicate_context(s->thread_context[i]);
842	}
843	for(i=1; i<s->avctx->thread_count; i++){
844	av_freep(&s->thread_context[i]);
845	}
846
847	av_freep(&s->parse_context.buffer);
848	s->parse_context.buffer_size=0;
849
850	av_freep(&s->mb_type);
851	av_freep(&s->p_mv_table_base);
852	av_freep(&s->b_forw_mv_table_base);
853	av_freep(&s->b_back_mv_table_base);
854	av_freep(&s->b_bidir_forw_mv_table_base);
855	av_freep(&s->b_bidir_back_mv_table_base);
856	av_freep(&s->b_direct_mv_table_base);
857	s->p_mv_table= NULL;
858	s->b_forw_mv_table= NULL;
859	s->b_back_mv_table= NULL;
860	s->b_bidir_forw_mv_table= NULL;
861	s->b_bidir_back_mv_table= NULL;
862	s->b_direct_mv_table= NULL;
863	for(i=0; i<2; i++){
864	for(j=0; j<2; j++){
865	for(k=0; k<2; k++){
866	av_freep(&s->b_field_mv_table_base[i][j][k]);
867	s->b_field_mv_table[i][j][k]=NULL;
868	}
869	av_freep(&s->b_field_select_table[i][j]);
870	av_freep(&s->p_field_mv_table_base[i][j]);
871	s->p_field_mv_table[i][j]=NULL;
872	}
873	av_freep(&s->p_field_select_table[i]);
874	}
875
876	av_freep(&s->dc_val_base);
877	av_freep(&s->ac_val_base);
878	av_freep(&s->coded_block_base);
879	av_freep(&s->mbintra_table);
880	av_freep(&s->cbp_table);
881	av_freep(&s->pred_dir_table);
882
883	av_freep(&s->mbskip_table);
884	av_freep(&s->prev_pict_types);
885	av_freep(&s->bitstream_buffer);
886	s->allocated_bitstream_buffer_size=0;
887
888	av_freep(&s->avctx->stats_out);
889	av_freep(&s->ac_stats);
890	av_freep(&s->error_status_table);
891	av_freep(&s->mb_index2xy);
892	av_freep(&s->lambda_table);
893	av_freep(&s->q_intra_matrix);
894	av_freep(&s->q_inter_matrix);
895	av_freep(&s->q_intra_matrix16);
896	av_freep(&s->q_inter_matrix16);
897	av_freep(&s->input_picture);
898	av_freep(&s->reordered_input_picture);
899	av_freep(&s->dct_offset);
900
901	if(s->picture){
902	for(i=0; i<MAX_PICTURE_COUNT; i++){
903	free_picture(s, &s->picture[i]);
904	}
905	}
906	av_freep(&s->picture);
907	s->context_initialized = 0;
908	s->last_picture_ptr=
909	s->next_picture_ptr=
910	s->current_picture_ptr= NULL;
911	s->linesize= s->uvlinesize= 0;
912
913	for(i=0; i<3; i++)
914	av_freep(&s->visualization_buffer[i]);
915
916	avcodec_default_free_buffers(s->avctx);
917	}
918
919	#ifdef CONFIG_ENCODERS
920
921	/* init video encoder */
922	int MPV_encode_init(AVCodecContext *avctx)
923	{
924	MpegEncContext *s = avctx->priv_data;
925	int i;
926	int chroma_h_shift, chroma_v_shift;
927
928	MPV_encode_defaults(s);
929
930	switch (avctx->codec_id) {
931	case CODEC_ID_MPEG2VIDEO:
932	if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
933	av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
934	return -1;
935	}
936	break;
937	case CODEC_ID_LJPEG:
938	case CODEC_ID_MJPEG:
939	if(avctx->pix_fmt != PIX_FMT_YUVJ420P && (avctx->pix_fmt != PIX_FMT_YUV420P \|\| avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
940	av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
941	return -1;
942	}
943	break;
944	default:
945	if(avctx->pix_fmt != PIX_FMT_YUV420P){
946	av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
947	return -1;
948	}
949	}
950
951	switch (avctx->pix_fmt) {
952	case PIX_FMT_YUVJ422P:
953	case PIX_FMT_YUV422P:
954	s->chroma_format = CHROMA_422;
955	break;
956	case PIX_FMT_YUVJ420P:
957	case PIX_FMT_YUV420P:
958	default:
959	s->chroma_format = CHROMA_420;
960	break;
961	}
962
963	s->bit_rate = avctx->bit_rate;
964	s->width = avctx->width;
965	s->height = avctx->height;
966	if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
967	av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
968	avctx->gop_size=600;
969	}
970	s->gop_size = avctx->gop_size;
971	s->avctx = avctx;
972	s->flags= avctx->flags;
973	s->flags2= avctx->flags2;
974	s->max_b_frames= avctx->max_b_frames;
975	s->codec_id= avctx->codec->id;
976	s->luma_elim_threshold = avctx->luma_elim_threshold;
977	s->chroma_elim_threshold= avctx->chroma_elim_threshold;
978	s->strict_std_compliance= avctx->strict_std_compliance;
979	s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
980	s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
981	s->mpeg_quant= avctx->mpeg_quant;
982	s->rtp_mode= !!avctx->rtp_payload_size;
983	s->intra_dc_precision= avctx->intra_dc_precision;
984	s->user_specified_pts = AV_NOPTS_VALUE;
985
986	if (s->gop_size <= 1) {
987	s->intra_only = 1;
988	s->gop_size = 12;
989	} else {
990	s->intra_only = 0;
991	}
992
993	s->me_method = avctx->me_method;
994
995	/* Fixed QSCALE */
996	s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
997
998	s->adaptive_quant= ( s->avctx->lumi_masking
999	\|\| s->avctx->dark_masking
1000	\|\| s->avctx->temporal_cplx_masking
1001	\|\| s->avctx->spatial_cplx_masking
1002	\|\| s->avctx->p_masking
1003	\|\| s->avctx->border_masking
1004	\|\| (s->flags&CODEC_FLAG_QP_RD))
1005	&& !s->fixed_qscale;
1006
1007	s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1008	s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1009	s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1010	s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1011
1012	if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1013	av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1014	return -1;
1015	}
1016
1017	if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1018	av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1019	}
1020
1021	if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1022	av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1023	return -1;
1024	}
1025
1026	if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1027	av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1028	return -1;
1029	}
1030
1031	if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1032	&& (s->codec_id == CODEC_ID_MPEG1VIDEO \|\| s->codec_id == CODEC_ID_MPEG2VIDEO)
1033	&& 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1034
1035	av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
1036	}
1037
1038	if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1039	&& s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1040	av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1041	return -1;
1042	}
1043
1044	if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1045	av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1046	return -1;
1047	}
1048
1049	if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1050	av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1051	return -1;
1052	}
1053
1054	if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1055	av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1056	return -1;
1057	}
1058
1059	if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1060	av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1061	return -1;
1062	}
1063
1064	if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1065	av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1066	return -1;
1067	}
1068
1069	if((s->flags & (CODEC_FLAG_INTERLACED_DCT\|CODEC_FLAG_INTERLACED_ME\|CODEC_FLAG_ALT_SCAN))
1070	&& s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1071	av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1072	return -1;
1073	}
1074
1075	if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1076	av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1077	return -1;
1078	}
1079
1080	if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1081	av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1082	return -1;
1083	}
1084
1085	if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1086	av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1087	return -1;
1088	}
1089
1090	if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1091	av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1092	return -1;
1093	}
1094
1095	if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1096	av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1097	return -1;
1098	}
1099
1100	if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1101	&& s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1102	&& (s->codec_id != CODEC_ID_H263P \|\| !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1103	av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1104	return -1;
1105	}
1106
1107	if(s->avctx->thread_count > 1)
1108	s->rtp_mode= 1;
1109
1110	if(!avctx->time_base.den \|\| !avctx->time_base.num){
1111	av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1112	return -1;
1113	}
1114
1115	i= (INT_MAX/2+128)>>8;
1116	if(avctx->me_threshold >= i){
1117	av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1118	return -1;
1119	}
1120	if(avctx->mb_threshold >= i){
1121	av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1122	return -1;
1123	}
1124
1125	if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1126	av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1127	avctx->b_frame_strategy = 0;
1128	}
1129
1130	i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1131	if(i > 1){
1132	av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1133	avctx->time_base.den /= i;
1134	avctx->time_base.num /= i;
1135	// return -1;
1136	}
1137
1138	if(s->codec_id==CODEC_ID_MJPEG){
1139	s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1140	s->inter_quant_bias= 0;
1141	}else if(s->mpeg_quant \|\| s->codec_id==CODEC_ID_MPEG1VIDEO \|\| s->codec_id==CODEC_ID_MPEG2VIDEO){
1142	s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1143	s->inter_quant_bias= 0;
1144	}else{
1145	s->intra_quant_bias=0;
1146	s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1147	}
1148
1149	if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1150	s->intra_quant_bias= avctx->intra_quant_bias;
1151	if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1152	s->inter_quant_bias= avctx->inter_quant_bias;
1153
1154	avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1155
1156	if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1157	av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1158	return -1;
1159	}
1160	s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1161
1162	switch(avctx->codec->id) {
1163	case CODEC_ID_MPEG1VIDEO:
1164	s->out_format = FMT_MPEG1;
1165	s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1166	avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1167	break;
1168	case CODEC_ID_MPEG2VIDEO:
1169	s->out_format = FMT_MPEG1;
1170	s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1171	avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1172	s->rtp_mode= 1;
1173	break;
1174	case CODEC_ID_LJPEG:
1175	case CODEC_ID_JPEGLS:
1176	case CODEC_ID_MJPEG:
1177	s->out_format = FMT_MJPEG;
1178	s->intra_only = 1; /* force intra only for jpeg */
1179	s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1180	s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1181	s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1182	s->mjpeg_vsample[1] = 1;
1183	s->mjpeg_vsample[2] = 1;
1184	s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1185	s->mjpeg_hsample[1] = 1;
1186	s->mjpeg_hsample[2] = 1;
1187	if (mjpeg_init(s) < 0)
1188	return -1;
1189	avctx->delay=0;
1190	s->low_delay=1;
1191	break;
1192	case CODEC_ID_H261:
1193	s->out_format = FMT_H261;
1194	avctx->delay=0;
1195	s->low_delay=1;
1196	break;
1197	case CODEC_ID_H263:
1198	if (h263_get_picture_format(s->width, s->height) == 7) {
1199	av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
1200	return -1;
1201	}
1202	s->out_format = FMT_H263;
1203	s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1204	avctx->delay=0;
1205	s->low_delay=1;
1206	break;
1207	case CODEC_ID_H263P:
1208	s->out_format = FMT_H263;
1209	s->h263_plus = 1;
1210	/* Fx */
1211	s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1212	s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1213	s->modified_quant= s->h263_aic;
1214	s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1215	s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1216	s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1217	s->unrestricted_mv= s->obmc \|\| s->loop_filter \|\| s->umvplus;
1218	s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1219
1220	/* /Fx */
1221	/* These are just to be sure */
1222	avctx->delay=0;
1223	s->low_delay=1;
1224	break;
1225	case CODEC_ID_FLV1:
1226	s->out_format = FMT_H263;
1227	s->h263_flv = 2; /* format = 1; 11-bit codes */
1228	s->unrestricted_mv = 1;
1229	s->rtp_mode=0; /* don't allow GOB */
1230	avctx->delay=0;
1231	s->low_delay=1;
1232	break;
1233	case CODEC_ID_RV10:
1234	s->out_format = FMT_H263;
1235	avctx->delay=0;
1236	s->low_delay=1;
1237	break;
1238	case CODEC_ID_RV20:
1239	s->out_format = FMT_H263;
1240	avctx->delay=0;
1241	s->low_delay=1;
1242	s->modified_quant=1;
1243	s->h263_aic=1;
1244	s->h263_plus=1;
1245	s->loop_filter=1;
1246	s->unrestricted_mv= s->obmc \|\| s->loop_filter \|\| s->umvplus;
1247	break;
1248	case CODEC_ID_MPEG4:
1249	s->out_format = FMT_H263;
1250	s->h263_pred = 1;
1251	s->unrestricted_mv = 1;
1252	s->low_delay= s->max_b_frames ? 0 : 1;
1253	avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1254	break;
1255	case CODEC_ID_MSMPEG4V1:
1256	s->out_format = FMT_H263;
1257	s->h263_msmpeg4 = 1;
1258	s->h263_pred = 1;
1259	s->unrestricted_mv = 1;
1260	s->msmpeg4_version= 1;
1261	avctx->delay=0;
1262	s->low_delay=1;
1263	break;
1264	case CODEC_ID_MSMPEG4V2:
1265	s->out_format = FMT_H263;
1266	s->h263_msmpeg4 = 1;
1267	s->h263_pred = 1;
1268	s->unrestricted_mv = 1;
1269	s->msmpeg4_version= 2;
1270	avctx->delay=0;
1271	s->low_delay=1;
1272	break;
1273	case CODEC_ID_MSMPEG4V3:
1274	s->out_format = FMT_H263;
1275	s->h263_msmpeg4 = 1;
1276	s->h263_pred = 1;
1277	s->unrestricted_mv = 1;
1278	s->msmpeg4_version= 3;
1279	s->flipflop_rounding=1;
1280	avctx->delay=0;
1281	s->low_delay=1;
1282	break;
1283	case CODEC_ID_WMV1:
1284	s->out_format = FMT_H263;
1285	s->h263_msmpeg4 = 1;
1286	s->h263_pred = 1;
1287	s->unrestricted_mv = 1;
1288	s->msmpeg4_version= 4;
1289	s->flipflop_rounding=1;
1290	avctx->delay=0;
1291	s->low_delay=1;
1292	break;
1293	case CODEC_ID_WMV2:
1294	s->out_format = FMT_H263;
1295	s->h263_msmpeg4 = 1;
1296	s->h263_pred = 1;
1297	s->unrestricted_mv = 1;
1298	s->msmpeg4_version= 5;
1299	s->flipflop_rounding=1;
1300	avctx->delay=0;
1301	s->low_delay=1;
1302	break;
1303	default:
1304	return -1;
1305	}
1306
1307	avctx->has_b_frames= !s->low_delay;
1308
1309	s->encoding = 1;
1310
1311	/* init */
1312	if (MPV_common_init(s) < 0)
1313	return -1;
1314
1315	if(s->modified_quant)
1316	s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1317	s->progressive_frame=
1318	s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT\|CODEC_FLAG_INTERLACED_ME));
1319	s->quant_precision=5;
1320
1321	ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1322	ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1323
1324	#ifdef CONFIG_H261_ENCODER
1325	if (s->out_format == FMT_H261)
1326	ff_h261_encode_init(s);
1327	#endif
1328	if (s->out_format == FMT_H263)
1329	h263_encode_init(s);
1330	if(s->msmpeg4_version)
1331	ff_msmpeg4_encode_init(s);
1332	if (s->out_format == FMT_MPEG1)
1333	ff_mpeg1_encode_init(s);
1334
1335	/* init q matrix */
1336	for(i=0;i<64;i++) {
1337	int j= s->dsp.idct_permutation[i];
1338	if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1339	s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1340	s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1341	}else if(s->out_format == FMT_H263 \|\| s->out_format == FMT_H261){
1342	s->intra_matrix[j] =
1343	s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1344	}else
1345	{ /* mpeg1/2 */
1346	s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1347	s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1348	}
1349	if(s->avctx->intra_matrix)
1350	s->intra_matrix[j] = s->avctx->intra_matrix[i];
1351	if(s->avctx->inter_matrix)
1352	s->inter_matrix[j] = s->avctx->inter_matrix[i];
1353	}
1354
1355	/* precompute matrix */
1356	/* for mjpeg, we do include qscale in the matrix */
1357	if (s->out_format != FMT_MJPEG) {
1358	convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1359	s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1360	convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1361	s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1362	}
1363
1364	if(ff_rate_control_init(s) < 0)
1365	return -1;
1366
1367	return 0;
1368	}
1369
1370	int MPV_encode_end(AVCodecContext *avctx)
1371	{
1372	MpegEncContext *s = avctx->priv_data;
1373
1374	ff_rate_control_uninit(s);
1375
1376	MPV_common_end(s);
1377	if (s->out_format == FMT_MJPEG)
1378	mjpeg_close(s);
1379
1380	av_freep(&avctx->extradata);
1381
1382	return 0;
1383	}
1384
1385	#endif //CONFIG_ENCODERS
1386
1387	void init_rl(RLTable *rl, int use_static)
1388	{
1389	int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1390	uint8_t index_run[MAX_RUN+1];
1391	int last, run, level, start, end, i;
1392
1393	/* If table is static, we can quit if rl->max_level[0] is not NULL */
1394	if(use_static && rl->max_level[0])
1395	return;
1396
1397	/* compute max_level[], max_run[] and index_run[] */
1398	for(last=0;last<2;last++) {
1399	if (last == 0) {
1400	start = 0;
1401	end = rl->last;
1402	} else {
1403	start = rl->last;
1404	end = rl->n;
1405	}
1406
1407	memset(max_level, 0, MAX_RUN + 1);
1408	memset(max_run, 0, MAX_LEVEL + 1);
1409	memset(index_run, rl->n, MAX_RUN + 1);
1410	for(i=start;i<end;i++) {
1411	run = rl->table_run[i];
1412	level = rl->table_level[i];
1413	if (index_run[run] == rl->n)
1414	index_run[run] = i;
1415	if (level > max_level[run])
1416	max_level[run] = level;
1417	if (run > max_run[level])
1418	max_run[level] = run;
1419	}
1420	if(use_static)
1421	rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1422	else
1423	rl->max_level[last] = av_malloc(MAX_RUN + 1);
1424	memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1425	if(use_static)
1426	rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1427	else
1428	rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1429	memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1430	if(use_static)
1431	rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1432	else
1433	rl->index_run[last] = av_malloc(MAX_RUN + 1);
1434	memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1435	}
1436	}
1437
1438	/* draw the edges of width 'w' of an image of size width, height */
1439	//FIXME check that this is ok for mpeg4 interlaced
1440	static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1441	{
1442	uint8_t ptr, last_line;
1443	int i;
1444
1445	last_line = buf + (height - 1) * wrap;
1446	for(i=0;i<w;i++) {
1447	/* top and bottom */
1448	memcpy(buf - (i + 1) * wrap, buf, width);
1449	memcpy(last_line + (i + 1) * wrap, last_line, width);
1450	}
1451	/* left and right */
1452	ptr = buf;
1453	for(i=0;i<height;i++) {
1454	memset(ptr - w, ptr[0], w);
1455	memset(ptr + width, ptr[width-1], w);
1456	ptr += wrap;
1457	}
1458	/* corners */
1459	for(i=0;i<w;i++) {
1460	memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1461	memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1462	memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1463	memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1464	}
1465	}
1466
1467	int ff_find_unused_picture(MpegEncContext *s, int shared){
1468	int i;
1469
1470	if(shared){
1471	for(i=0; i<MAX_PICTURE_COUNT; i++){
1472	if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1473	}
1474	}else{
1475	for(i=0; i<MAX_PICTURE_COUNT; i++){
1476	if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1477	}
1478	for(i=0; i<MAX_PICTURE_COUNT; i++){
1479	if(s->picture[i].data[0]==NULL) return i;
1480	}
1481	}
1482
1483	assert(0);
1484	return -1;
1485	}
1486
1487	static void update_noise_reduction(MpegEncContext *s){
1488	int intra, i;
1489
1490	for(intra=0; intra<2; intra++){
1491	if(s->dct_count[intra] > (1<<16)){
1492	for(i=0; i<64; i++){
1493	s->dct_error_sum[intra][i] >>=1;
1494	}
1495	s->dct_count[intra] >>= 1;
1496	}
1497
1498	for(i=0; i<64; i++){
1499	s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1500	}
1501	}
1502	}
1503
1504	/**
1505	* generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1506	*/
1507	int MPV_frame_start(MpegEncContext s, AVCodecContext avctx)
1508	{
1509	int i;
1510	AVFrame *pic;
1511	s->mb_skipped = 0;
1512
1513	assert(s->last_picture_ptr==NULL \|\| s->out_format != FMT_H264 \|\| s->codec_id == CODEC_ID_SVQ3);
1514
1515	/* mark&release old frames */
1516	if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1517	avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1518
1519	/* release forgotten pictures */
1520	/* if(mpeg124/h263) */
1521	if(!s->encoding){
1522	for(i=0; i<MAX_PICTURE_COUNT; i++){
1523	if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1524	av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1525	avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1526	}
1527	}
1528	}
1529	}
1530	alloc:
1531	if(!s->encoding){
1532	/* release non reference frames */
1533	for(i=0; i<MAX_PICTURE_COUNT; i++){
1534	if(s->picture[i].data[0] && !s->picture[i].reference /&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED/){
1535	s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1536	}
1537	}
1538
1539	if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1540	pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1541	else{
1542	i= ff_find_unused_picture(s, 0);
1543	pic= (AVFrame*)&s->picture[i];
1544	}
1545
1546	pic->reference= (s->pict_type != B_TYPE \|\| s->codec_id == CODEC_ID_H264)
1547	&& !s->dropable ? 3 : 0;
1548
1549	pic->coded_picture_number= s->coded_picture_number++;
1550
1551	if( alloc_picture(s, (Picture*)pic, 0) < 0)
1552	return -1;
1553
1554	s->current_picture_ptr= (Picture*)pic;
1555	s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1556	s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1557	}
1558
1559	s->current_picture_ptr->pict_type= s->pict_type;
1560	// if(s->flags && CODEC_FLAG_QSCALE)
1561	// s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1562	s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1563
1564	copy_picture(&s->current_picture, s->current_picture_ptr);
1565
1566	if(s->out_format != FMT_H264 \|\| s->codec_id == CODEC_ID_SVQ3){
1567	if (s->pict_type != B_TYPE) {
1568	s->last_picture_ptr= s->next_picture_ptr;
1569	if(!s->dropable)
1570	s->next_picture_ptr= s->current_picture_ptr;
1571	}
1572	/* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1573	s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1574	s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1575	s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1576	s->pict_type, s->dropable);*/
1577
1578	if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1579	if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1580
1581	if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL \|\| s->last_picture_ptr->data[0]==NULL)){
1582	av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1583	assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1584	goto alloc;
1585	}
1586
1587	assert(s->pict_type == I_TYPE \|\| (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1588
1589	if(s->picture_structure!=PICT_FRAME){
1590	int i;
1591	for(i=0; i<4; i++){
1592	if(s->picture_structure == PICT_BOTTOM_FIELD){
1593	s->current_picture.data[i] += s->current_picture.linesize[i];
1594	}
1595	s->current_picture.linesize[i] *= 2;
1596	s->last_picture.linesize[i] *=2;
1597	s->next_picture.linesize[i] *=2;
1598	}
1599	}
1600	}
1601
1602	s->hurry_up= s->avctx->hurry_up;
1603	s->error_resilience= avctx->error_resilience;
1604
1605	/* set dequantizer, we can't do it during init as it might change for mpeg4
1606	and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1607	if(s->mpeg_quant \|\| s->codec_id == CODEC_ID_MPEG2VIDEO){
1608	s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1609	s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1610	}else if(s->out_format == FMT_H263 \|\| s->out_format == FMT_H261){
1611	s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1612	s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1613	}else{
1614	s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1615	s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1616	}
1617
1618	if(s->dct_error_sum){
1619	assert(s->avctx->noise_reduction && s->encoding);
1620
1621	update_noise_reduction(s);
1622	}
1623
1624	#ifdef HAVE_XVMC
1625	if(s->avctx->xvmc_acceleration)
1626	return XVMC_field_start(s, avctx);
1627	#endif
1628	return 0;
1629	}
1630
1631	/* generic function for encode/decode called after a frame has been coded/decoded */
1632	void MPV_frame_end(MpegEncContext *s)
1633	{
1634	int i;
1635	/* draw edge for correct motion prediction if outside */
1636	#ifdef HAVE_XVMC
1637	//just to make sure that all data is rendered.
1638	if(s->avctx->xvmc_acceleration){
1639	XVMC_field_end(s);
1640	}else
1641	#endif
1642	if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1643	draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1644	draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1645	draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1646	}
1647	emms_c();
1648
1649	s->last_pict_type = s->pict_type;
1650	s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1651	if(s->pict_type!=B_TYPE){
1652	s->last_non_b_pict_type= s->pict_type;
1653	}
1654	#if 0
1655	/* copy back current_picture variables */
1656	for(i=0; i<MAX_PICTURE_COUNT; i++){
1657	if(s->picture[i].data[0] == s->current_picture.data[0]){
1658	s->picture[i]= s->current_picture;
1659	break;
1660	}
1661	}
1662	assert(i<MAX_PICTURE_COUNT);
1663	#endif
1664
1665	if(s->encoding){
1666	/* release non-reference frames */
1667	for(i=0; i<MAX_PICTURE_COUNT; i++){
1668	if(s->picture[i].data[0] && !s->picture[i].reference /&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED/){
1669	s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1670	}
1671	}
1672	}
1673	// clear copies, to avoid confusion
1674	#if 0
1675	memset(&s->last_picture, 0, sizeof(Picture));
1676	memset(&s->next_picture, 0, sizeof(Picture));
1677	memset(&s->current_picture, 0, sizeof(Picture));
1678	#endif
1679	s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1680	}
1681
1682	/**
1683	* draws an line from (ex, ey) -> (sx, sy).
1684	* @param w width of the image
1685	* @param h height of the image
1686	* @param stride stride/linesize of the image
1687	* @param color color of the arrow
1688	*/
1689	static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1690	int t, x, y, fr, f;
1691
1692	sx= clip(sx, 0, w-1);
1693	sy= clip(sy, 0, h-1);
1694	ex= clip(ex, 0, w-1);
1695	ey= clip(ey, 0, h-1);
1696
1697	buf[sy*stride + sx]+= color;
1698
1699	if(ABS(ex - sx) > ABS(ey - sy)){
1700	if(sx > ex){
1701	t=sx; sx=ex; ex=t;
1702	t=sy; sy=ey; ey=t;
1703	}
1704	buf+= sx + sy*stride;
1705	ex-= sx;
1706	f= ((ey-sy)<<16)/ex;
1707	for(x= 0; x <= ex; x++){
1708	y = (x*f)>>16;
1709	fr= (x*f)&0xFFFF;
1710	buf[ y stride + x]+= (color(0x10000-fr))>>16;
1711	buf[(y+1)stride + x]+= (color fr )>>16;
1712	}
1713	}else{
1714	if(sy > ey){
1715	t=sx; sx=ex; ex=t;
1716	t=sy; sy=ey; ey=t;
1717	}
1718	buf+= sx + sy*stride;
1719	ey-= sy;
1720	if(ey) f= ((ex-sx)<<16)/ey;
1721	else f= 0;
1722	for(y= 0; y <= ey; y++){
1723	x = (y*f)>>16;
1724	fr= (y*f)&0xFFFF;
1725	buf[ystride + x ]+= (color(0x10000-fr))>>16;;
1726	buf[ystride + x+1]+= (color fr )>>16;;
1727	}
1728	}
1729	}
1730
1731	/**
1732	* draws an arrow from (ex, ey) -> (sx, sy).
1733	* @param w width of the image
1734	* @param h height of the image
1735	* @param stride stride/linesize of the image
1736	* @param color color of the arrow
1737	*/
1738	static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1739	int dx,dy;
1740
1741	sx= clip(sx, -100, w+100);
1742	sy= clip(sy, -100, h+100);
1743	ex= clip(ex, -100, w+100);
1744	ey= clip(ey, -100, h+100);
1745
1746	dx= ex - sx;
1747	dy= ey - sy;
1748
1749	if(dxdx + dydy > 3*3){
1750	int rx= dx + dy;
1751	int ry= -dx + dy;
1752	int length= ff_sqrt((rxrx + ryry)<<8);
1753
1754	//FIXME subpixel accuracy
1755	rx= ROUNDED_DIV(rx*3<<4, length);
1756	ry= ROUNDED_DIV(ry*3<<4, length);
1757
1758	draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1759	draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1760	}
1761	draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1762	}
1763
1764	/**
1765	* prints debuging info for the given picture.
1766	*/
1767	void ff_print_debug_info(MpegEncContext s, AVFrame pict){
1768
1769	if(!pict \|\| !pict->mb_type) return;
1770
1771	if(s->avctx->debug&(FF_DEBUG_SKIP \| FF_DEBUG_QP \| FF_DEBUG_MB_TYPE)){
1772	int x,y;
1773
1774	av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1775	switch (pict->pict_type) {
1776	case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1777	case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1778	case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1779	case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1780	case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1781	case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1782	}
1783	for(y=0; y<s->mb_height; y++){
1784	for(x=0; x<s->mb_width; x++){
1785	if(s->avctx->debug&FF_DEBUG_SKIP){
1786	int count= s->mbskip_table[x + y*s->mb_stride];
1787	if(count>9) count=9;
1788	av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1789	}
1790	if(s->avctx->debug&FF_DEBUG_QP){
1791	av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1792	}
1793	if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1794	int mb_type= pict->mb_type[x + y*s->mb_stride];
1795	//Type & MV direction
1796	if(IS_PCM(mb_type))
1797	av_log(s->avctx, AV_LOG_DEBUG, "P");
1798	else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1799	av_log(s->avctx, AV_LOG_DEBUG, "A");
1800	else if(IS_INTRA4x4(mb_type))
1801	av_log(s->avctx, AV_LOG_DEBUG, "i");
1802	else if(IS_INTRA16x16(mb_type))
1803	av_log(s->avctx, AV_LOG_DEBUG, "I");
1804	else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1805	av_log(s->avctx, AV_LOG_DEBUG, "d");
1806	else if(IS_DIRECT(mb_type))
1807	av_log(s->avctx, AV_LOG_DEBUG, "D");
1808	else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1809	av_log(s->avctx, AV_LOG_DEBUG, "g");
1810	else if(IS_GMC(mb_type))
1811	av_log(s->avctx, AV_LOG_DEBUG, "G");
1812	else if(IS_SKIP(mb_type))
1813	av_log(s->avctx, AV_LOG_DEBUG, "S");
1814	else if(!USES_LIST(mb_type, 1))
1815	av_log(s->avctx, AV_LOG_DEBUG, ">");
1816	else if(!USES_LIST(mb_type, 0))
1817	av_log(s->avctx, AV_LOG_DEBUG, "<");
1818	else{
1819	assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1820	av_log(s->avctx, AV_LOG_DEBUG, "X");
1821	}
1822
1823	//segmentation
1824	if(IS_8X8(mb_type))
1825	av_log(s->avctx, AV_LOG_DEBUG, "+");
1826	else if(IS_16X8(mb_type))
1827	av_log(s->avctx, AV_LOG_DEBUG, "-");
1828	else if(IS_8X16(mb_type))
1829	av_log(s->avctx, AV_LOG_DEBUG, "\|");
1830	else if(IS_INTRA(mb_type) \|\| IS_16X16(mb_type))
1831	av_log(s->avctx, AV_LOG_DEBUG, " ");
1832	else
1833	av_log(s->avctx, AV_LOG_DEBUG, "?");
1834
1835
1836	if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1837	av_log(s->avctx, AV_LOG_DEBUG, "=");
1838	else
1839	av_log(s->avctx, AV_LOG_DEBUG, " ");
1840	}
1841	// av_log(s->avctx, AV_LOG_DEBUG, " ");
1842	}
1843	av_log(s->avctx, AV_LOG_DEBUG, "\n");
1844	}
1845	}
1846
1847	if((s->avctx->debug&(FF_DEBUG_VIS_QP\|FF_DEBUG_VIS_MB_TYPE)) \|\| (s->avctx->debug_mv)){
1848	const int shift= 1 + s->quarter_sample;
1849	int mb_y;
1850	uint8_t *ptr;
1851	int i;
1852	int h_chroma_shift, v_chroma_shift;
1853	const int width = s->avctx->width;
1854	const int height= s->avctx->height;
1855	const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1856	const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1857	s->low_delay=0; //needed to see the vectors without trashing the buffers
1858
1859	avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1860	for(i=0; i<3; i++){
1861	memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]height:pict->linesize[i]height >> v_chroma_shift);
1862	pict->data[i]= s->visualization_buffer[i];
1863	}
1864	pict->type= FF_BUFFER_TYPE_COPY;
1865	ptr= pict->data[0];
1866
1867	for(mb_y=0; mb_y<s->mb_height; mb_y++){
1868	int mb_x;
1869	for(mb_x=0; mb_x<s->mb_width; mb_x++){
1870	const int mb_index= mb_x + mb_y*s->mb_stride;
1871	if((s->avctx->debug_mv) && pict->motion_val){
1872	int type;
1873	for(type=0; type<3; type++){
1874	int direction = 0;
1875	switch (type) {
1876	case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) \|\| (pict->pict_type!=FF_P_TYPE))
1877	continue;
1878	direction = 0;
1879	break;
1880	case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) \|\| (pict->pict_type!=FF_B_TYPE))
1881	continue;
1882	direction = 0;
1883	break;
1884	case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) \|\| (pict->pict_type!=FF_B_TYPE))
1885	continue;
1886	direction = 1;
1887	break;
1888	}
1889	if(!USES_LIST(pict->mb_type[mb_index], direction))
1890	continue;
1891
1892	if(IS_8X8(pict->mb_type[mb_index])){
1893	int i;
1894	for(i=0; i<4; i++){
1895	int sx= mb_x16 + 4 + 8(i&1);
1896	int sy= mb_y16 + 4 + 8(i>>1);
1897	int xy= (mb_x2 + (i&1) + (mb_y2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1898	int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1899	int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1900	draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1901	}
1902	}else if(IS_16X8(pict->mb_type[mb_index])){
1903	int i;
1904	for(i=0; i<2; i++){
1905	int sx=mb_x*16 + 8;
1906	int sy=mb_y16 + 4 + 8i;
1907	int xy= (mb_x2 + (mb_y2 + i)*mv_stride) << (mv_sample_log2-1);
1908	int mx=(pict->motion_val[direction][xy][0]>>shift);
1909	int my=(pict->motion_val[direction][xy][1]>>shift);
1910
1911	if(IS_INTERLACED(pict->mb_type[mb_index]))
1912	my*=2;
1913
1914	draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1915	}
1916	}else if(IS_8X16(pict->mb_type[mb_index])){
1917	int i;
1918	for(i=0; i<2; i++){
1919	int sx=mb_x16 + 4 + 8i;
1920	int sy=mb_y*16 + 8;
1921	int xy= (mb_x2 + i + mb_y2*mv_stride) << (mv_sample_log2-1);
1922	int mx=(pict->motion_val[direction][xy][0]>>shift);
1923	int my=(pict->motion_val[direction][xy][1]>>shift);
1924
1925	if(IS_INTERLACED(pict->mb_type[mb_index]))
1926	my*=2;
1927
1928	draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1929	}
1930	}else{
1931	int sx= mb_x*16 + 8;
1932	int sy= mb_y*16 + 8;
1933	int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1934	int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1935	int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1936	draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1937	}
1938	}
1939	}
1940	if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1941	uint64_t c= (pict->qscale_table[mb_index]128/31) 0x0101010101010101ULL;
1942	int y;
1943	for(y=0; y<8; y++){
1944	(uint64_t)(pict->data[1] + 8mb_x + (8mb_y + y)*pict->linesize[1])= c;
1945	(uint64_t)(pict->data[2] + 8mb_x + (8mb_y + y)*pict->linesize[2])= c;
1946	}
1947	}
1948	if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1949	int mb_type= pict->mb_type[mb_index];
1950	uint64_t u,v;
1951	int y;
1952	#define COLOR(theta, r)\
1953	u= (int)(128 + rcos(theta3.141592/180));\
1954	v= (int)(128 + rsin(theta3.141592/180));
1955
1956
1957	u=v=128;
1958	if(IS_PCM(mb_type)){
1959	COLOR(120,48)
1960	}else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) \|\| IS_INTRA16x16(mb_type)){
1961	COLOR(30,48)
1962	}else if(IS_INTRA4x4(mb_type)){
1963	COLOR(90,48)
1964	}else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1965	// COLOR(120,48)
1966	}else if(IS_DIRECT(mb_type)){
1967	COLOR(150,48)
1968	}else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1969	COLOR(170,48)
1970	}else if(IS_GMC(mb_type)){
1971	COLOR(190,48)
1972	}else if(IS_SKIP(mb_type)){
1973	// COLOR(180,48)
1974	}else if(!USES_LIST(mb_type, 1)){
1975	COLOR(240,48)
1976	}else if(!USES_LIST(mb_type, 0)){
1977	COLOR(0,48)
1978	}else{
1979	assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1980	COLOR(300,48)
1981	}
1982
1983	u*= 0x0101010101010101ULL;
1984	v*= 0x0101010101010101ULL;
1985	for(y=0; y<8; y++){
1986	(uint64_t)(pict->data[1] + 8mb_x + (8mb_y + y)*pict->linesize[1])= u;
1987	(uint64_t)(pict->data[2] + 8mb_x + (8mb_y + y)*pict->linesize[2])= v;
1988	}
1989
1990	//segmentation
1991	if(IS_8X8(mb_type) \|\| IS_16X8(mb_type)){
1992	(uint64_t)(pict->data[0] + 16mb_x + 0 + (16mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1993	(uint64_t)(pict->data[0] + 16mb_x + 8 + (16mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1994	}
1995	if(IS_8X8(mb_type) \|\| IS_8X16(mb_type)){
1996	for(y=0; y<16; y++)
1997	pict->data[0][16mb_x + 8 + (16mb_y + y)*pict->linesize[0]]^= 0x80;
1998	}
1999	if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2000	int dm= 1 << (mv_sample_log2-2);
2001	for(i=0; i<4; i++){
2002	int sx= mb_x16 + 8(i&1);
2003	int sy= mb_y16 + 8(i>>1);
2004	int xy= (mb_x2 + (i&1) + (mb_y2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2005	//FIXME bidir
2006	int32_t mv = (int32_t)&pict->motion_val[0][xy];
2007	if(mv[0] != mv[dm] \|\| mv[dmmv_stride] != mv[dm(mv_stride+1)])
2008	for(y=0; y<8; y++)
2009	pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2010	if(mv[0] != mv[dmmv_stride] \|\| mv[dm] != mv[dm(mv_stride+1)])
2011	(uint64_t)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2012	}
2013	}
2014
2015	if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2016	// hmm
2017	}
2018	}
2019	s->mbskip_table[mb_index]=0;
2020	}
2021	}
2022	}
2023	}
2024
2025	#ifdef CONFIG_ENCODERS
2026
2027	static int get_sae(uint8_t *src, int ref, int stride){
2028	int x,y;
2029	int acc=0;
2030
2031	for(y=0; y<16; y++){
2032	for(x=0; x<16; x++){
2033	acc+= ABS(src[x+y*stride] - ref);
2034	}
2035	}
2036
2037	return acc;
2038	}
2039
2040	static int get_intra_count(MpegEncContext s, uint8_t src, uint8_t *ref, int stride){
2041	int x, y, w, h;
2042	int acc=0;
2043
2044	w= s->width &~15;
2045	h= s->height&~15;
2046
2047	for(y=0; y<h; y+=16){
2048	for(x=0; x<w; x+=16){
2049	int offset= x + y*stride;
2050	int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2051	int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2052	int sae = get_sae(src + offset, mean, stride);
2053
2054	acc+= sae + 500 < sad;
2055	}
2056	}
2057	return acc;
2058	}
2059
2060
2061	static int load_input_picture(MpegEncContext s, AVFrame pic_arg){
2062	AVFrame *pic=NULL;
2063	int64_t pts;
2064	int i;
2065	const int encoding_delay= s->max_b_frames;
2066	int direct=1;
2067
2068	if(pic_arg){
2069	pts= pic_arg->pts;
2070	pic_arg->display_picture_number= s->input_picture_number++;
2071
2072	if(pts != AV_NOPTS_VALUE){
2073	if(s->user_specified_pts != AV_NOPTS_VALUE){
2074	int64_t time= pts;
2075	int64_t last= s->user_specified_pts;
2076
2077	if(time <= last){
2078	av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2079	return -1;
2080	}
2081	}
2082	s->user_specified_pts= pts;
2083	}else{
2084	if(s->user_specified_pts != AV_NOPTS_VALUE){
2085	s->user_specified_pts=
2086	pts= s->user_specified_pts + 1;
2087	av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2088	}else{
2089	pts= pic_arg->display_picture_number;
2090	}
2091	}
2092	}
2093
2094	if(pic_arg){
2095	if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2096	if(pic_arg->linesize[0] != s->linesize) direct=0;
2097	if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2098	if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2099
2100	// av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2101
2102	if(direct){
2103	i= ff_find_unused_picture(s, 1);
2104
2105	pic= (AVFrame*)&s->picture[i];
2106	pic->reference= 3;
2107
2108	for(i=0; i<4; i++){
2109	pic->data[i]= pic_arg->data[i];
2110	pic->linesize[i]= pic_arg->linesize[i];
2111	}
2112	alloc_picture(s, (Picture*)pic, 1);
2113	}else{
2114	i= ff_find_unused_picture(s, 0);
2115
2116	pic= (AVFrame*)&s->picture[i];
2117	pic->reference= 3;
2118
2119	alloc_picture(s, (Picture*)pic, 0);
2120
2121	if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2122	&& pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2123	&& pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2124	// empty
2125	}else{
2126	int h_chroma_shift, v_chroma_shift;
2127	avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2128
2129	for(i=0; i<3; i++){
2130	int src_stride= pic_arg->linesize[i];
2131	int dst_stride= i ? s->uvlinesize : s->linesize;
2132	int h_shift= i ? h_chroma_shift : 0;
2133	int v_shift= i ? v_chroma_shift : 0;
2134	int w= s->width >>h_shift;
2135	int h= s->height>>v_shift;
2136	uint8_t *src= pic_arg->data[i];
2137	uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2138
2139	if(src_stride==dst_stride)
2140	memcpy(dst, src, src_stride*h);
2141	else{
2142	while(h--){
2143	memcpy(dst, src, w);
2144	dst += dst_stride;
2145	src += src_stride;
2146	}
2147	}
2148	}
2149	}
2150	}
2151	copy_picture_attributes(s, pic, pic_arg);
2152	pic->pts= pts; //we set this here to avoid modifiying pic_arg
2153	}
2154
2155	/* shift buffer entries */
2156	for(i=1; i<MAX_PICTURE_COUNT /s->encoding_delay+1/; i++)
2157	s->input_picture[i-1]= s->input_picture[i];
2158
2159	s->input_picture[encoding_delay]= (Picture*)pic;
2160
2161	return 0;
2162	}
2163
2164	static int skip_check(MpegEncContext s, Picture p, Picture *ref){
2165	int x, y, plane;
2166	int score=0;
2167	int64_t score64=0;
2168
2169	for(plane=0; plane<3; plane++){
2170	const int stride= p->linesize[plane];
2171	const int bw= plane ? 1 : 2;
2172	for(y=0; y<s->mb_height*bw; y++){
2173	for(x=0; x<s->mb_width*bw; x++){
2174	int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2175	int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8(x + ystride)+off, ref->data[plane] + 8(x + ystride), stride, 8);
2176
2177	switch(s->avctx->frame_skip_exp){
2178	case 0: score= FFMAX(score, v); break;
2179	case 1: score+= ABS(v);break;
2180	case 2: score+= v*v;break;
2181	case 3: score64+= ABS(vv(int64_t)v);break;
2182	case 4: score64+= vv(int64_t)(v*v);break;
2183	}
2184	}
2185	}
2186	}
2187
2188	if(score) score64= score;
2189
2190	if(score64 < s->avctx->frame_skip_threshold)
2191	return 1;
2192	if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2193	return 1;
2194	return 0;
2195	}
2196
2197	static int estimate_best_b_count(MpegEncContext *s){
2198	AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2199	AVCodecContext *c= avcodec_alloc_context();
2200	AVFrame input[FF_MAX_B_FRAMES+2];
2201	const int scale= s->avctx->brd_scale;
2202	int i, j, out_size, p_lambda, b_lambda, lambda2;
2203	int outbuf_size= s->width * s->height; //FIXME
2204	uint8_t *outbuf= av_malloc(outbuf_size);
2205	int64_t best_rd= INT64_MAX;
2206	int best_b_count= -1;
2207
2208	assert(scale>=0 && scale <=3);
2209
2210	// emms_c();
2211	p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2212	b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2213	if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2214	lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2215
2216	c->width = s->width >> scale;
2217	c->height= s->height>> scale;
2218	c->flags= CODEC_FLAG_QSCALE \| CODEC_FLAG_PSNR \| CODEC_FLAG_INPUT_PRESERVED /\| CODEC_FLAG_EMU_EDGE/;
2219	c->flags\|= s->avctx->flags & CODEC_FLAG_QPEL;
2220	c->mb_decision= s->avctx->mb_decision;
2221	c->me_cmp= s->avctx->me_cmp;
2222	c->mb_cmp= s->avctx->mb_cmp;
2223	c->me_sub_cmp= s->avctx->me_sub_cmp;
2224	c->pix_fmt = PIX_FMT_YUV420P;
2225	c->time_base= s->avctx->time_base;
2226	c->max_b_frames= s->max_b_frames;
2227
2228	if (avcodec_open(c, codec) < 0)
2229	return -1;
2230
2231	for(i=0; i<s->max_b_frames+2; i++){
2232	int ysize= c->width*c->height;
2233	int csize= (c->width/2)*(c->height/2);
2234	Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2235
2236	if(pre_input_ptr)
2237	pre_input= *pre_input_ptr;
2238
2239	if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2240	pre_input.data[0]+=INPLACE_OFFSET;
2241	pre_input.data[1]+=INPLACE_OFFSET;
2242	pre_input.data[2]+=INPLACE_OFFSET;
2243	}
2244
2245	avcodec_get_frame_defaults(&input[i]);
2246	input[i].data[0]= av_malloc(ysize + 2*csize);
2247	input[i].data[1]= input[i].data[0] + ysize;
2248	input[i].data[2]= input[i].data[1] + csize;
2249	input[i].linesize[0]= c->width;
2250	input[i].linesize[1]=
2251	input[i].linesize[2]= c->width/2;
2252
2253	if(!i \|\| s->input_picture[i-1]){
2254	s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2255	s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2256	s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2257	}
2258	}
2259
2260	for(j=0; j<s->max_b_frames+1; j++){
2261	int64_t rd=0;
2262
2263	if(!s->input_picture[j])
2264	break;
2265
2266	c->error[0]= c->error[1]= c->error[2]= 0;
2267
2268	input[0].pict_type= I_TYPE;
2269	input[0].quality= 1 * FF_QP2LAMBDA;
2270	out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2271	// rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2272
2273	for(i=0; i<s->max_b_frames+1; i++){
2274	int is_p= i % (j+1) == j \|\| i==s->max_b_frames;
2275
2276	input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2277	input[i+1].quality= is_p ? p_lambda : b_lambda;
2278	out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2279	rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2280	}
2281
2282	/* get the delayed frames */
2283	while(out_size){
2284	out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2285	rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2286	}
2287
2288	rd += c->error[0] + c->error[1] + c->error[2];
2289
2290	if(rd < best_rd){
2291	best_rd= rd;
2292	best_b_count= j;
2293	}
2294	}
2295
2296	av_freep(&outbuf);
2297	avcodec_close(c);
2298	av_freep(&c);
2299
2300	for(i=0; i<s->max_b_frames+2; i++){
2301	av_freep(&input[i].data[0]);
2302	}
2303
2304	return best_b_count;
2305	}
2306
2307	static void select_input_picture(MpegEncContext *s){
2308	int i;
2309
2310	for(i=1; i<MAX_PICTURE_COUNT; i++)
2311	s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2312	s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2313
2314	/* set next picture type & ordering */
2315	if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2316	if(/s->picture_in_gop_number >= s->gop_size \|\|/ s->next_picture_ptr==NULL \|\| s->intra_only){
2317	s->reordered_input_picture[0]= s->input_picture[0];
2318	s->reordered_input_picture[0]->pict_type= I_TYPE;
2319	s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2320	}else{
2321	int b_frames;
2322
2323	if(s->avctx->frame_skip_threshold \|\| s->avctx->frame_skip_factor){
2324	if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2325	//FIXME check that te gop check above is +-1 correct
2326	//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2327
2328	if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2329	for(i=0; i<4; i++)
2330	s->input_picture[0]->data[i]= NULL;
2331	s->input_picture[0]->type= 0;
2332	}else{
2333	assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2334	\|\| s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2335
2336	s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2337	}
2338
2339	emms_c();
2340	ff_vbv_update(s, 0);
2341
2342	goto no_output_pic;
2343	}
2344	}
2345
2346	if(s->flags&CODEC_FLAG_PASS2){
2347	for(i=0; i<s->max_b_frames+1; i++){
2348	int pict_num= s->input_picture[0]->display_picture_number + i;
2349
2350	if(pict_num >= s->rc_context.num_entries)
2351	break;
2352	if(!s->input_picture[i]){
2353	s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2354	break;
2355	}
2356
2357	s->input_picture[i]->pict_type=
2358	s->rc_context.entry[pict_num].new_pict_type;
2359	}
2360	}
2361
2362	if(s->avctx->b_frame_strategy==0){
2363	b_frames= s->max_b_frames;
2364	while(b_frames && !s->input_picture[b_frames]) b_frames--;
2365	}else if(s->avctx->b_frame_strategy==1){
2366	for(i=1; i<s->max_b_frames+1; i++){
2367	if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2368	s->input_picture[i]->b_frame_score=
2369	get_intra_count(s, s->input_picture[i ]->data[0],
2370	s->input_picture[i-1]->data[0], s->linesize) + 1;
2371	}
2372	}
2373	for(i=0; i<s->max_b_frames+1; i++){
2374	if(s->input_picture[i]==NULL \|\| s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2375	}
2376
2377	b_frames= FFMAX(0, i-1);
2378
2379	/* reset scores */
2380	for(i=0; i<b_frames+1; i++){
2381	s->input_picture[i]->b_frame_score=0;
2382	}
2383	}else if(s->avctx->b_frame_strategy==2){
2384	b_frames= estimate_best_b_count(s);
2385	}else{
2386	av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2387	b_frames=0;
2388	}
2389
2390	emms_c();
2391	//static int b_count=0;
2392	//b_count+= b_frames;
2393	//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2394
2395	for(i= b_frames - 1; i>=0; i--){
2396	int type= s->input_picture[i]->pict_type;
2397	if(type && type != B_TYPE)
2398	b_frames= i;
2399	}
2400	if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2401	av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2402	}
2403
2404	if(s->picture_in_gop_number + b_frames >= s->gop_size){
2405	if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2406	b_frames= s->gop_size - s->picture_in_gop_number - 1;
2407	}else{
2408	if(s->flags & CODEC_FLAG_CLOSED_GOP)
2409	b_frames=0;
2410	s->input_picture[b_frames]->pict_type= I_TYPE;
2411	}
2412	}
2413
2414	if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2415	&& b_frames
2416	&& s->input_picture[b_frames]->pict_type== I_TYPE)
2417	b_frames--;
2418
2419	s->reordered_input_picture[0]= s->input_picture[b_frames];
2420	if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2421	s->reordered_input_picture[0]->pict_type= P_TYPE;
2422	s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2423	for(i=0; i<b_frames; i++){
2424	s->reordered_input_picture[i+1]= s->input_picture[i];
2425	s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2426	s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2427	}
2428	}
2429	}
2430	no_output_pic:
2431	if(s->reordered_input_picture[0]){
2432	s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2433
2434	copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2435
2436	if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2437	// input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2438
2439	int i= ff_find_unused_picture(s, 0);
2440	Picture *pic= &s->picture[i];
2441
2442	/* mark us unused / free shared pic */
2443	for(i=0; i<4; i++)
2444	s->reordered_input_picture[0]->data[i]= NULL;
2445	s->reordered_input_picture[0]->type= 0;
2446
2447	pic->reference = s->reordered_input_picture[0]->reference;
2448
2449	alloc_picture(s, pic, 0);
2450
2451	copy_picture_attributes(s, (AVFrame)pic, (AVFrame)s->reordered_input_picture[0]);
2452
2453	s->current_picture_ptr= pic;
2454	}else{
2455	// input is not a shared pix -> reuse buffer for current_pix
2456
2457	assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2458	\|\| s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2459
2460	s->current_picture_ptr= s->reordered_input_picture[0];
2461	for(i=0; i<4; i++){
2462	s->new_picture.data[i]+= INPLACE_OFFSET;
2463	}
2464	}
2465	copy_picture(&s->current_picture, s->current_picture_ptr);
2466
2467	s->picture_number= s->new_picture.display_picture_number;
2468	//printf("dpn:%d\n", s->picture_number);
2469	}else{
2470	memset(&s->new_picture, 0, sizeof(Picture));
2471	}
2472	}
2473
2474	int MPV_encode_picture(AVCodecContext *avctx,
2475	unsigned char buf, int buf_size, void data)
2476	{
2477	MpegEncContext *s = avctx->priv_data;
2478	AVFrame *pic_arg = data;
2479	int i, stuffing_count;
2480
2481	for(i=0; i<avctx->thread_count; i++){
2482	int start_y= s->thread_context[i]->start_mb_y;
2483	int end_y= s->thread_context[i]-> end_mb_y;
2484	int h= s->mb_height;
2485	uint8_t start= buf + (size_t)(((int64_t) buf_size)start_y/h);
2486	uint8_t end = buf + (size_t)(((int64_t) buf_size) end_y/h);
2487
2488	init_put_bits(&s->thread_context[i]->pb, start, end - start);
2489	}
2490
2491	s->picture_in_gop_number++;
2492
2493	if(load_input_picture(s, pic_arg) < 0)
2494	return -1;
2495
2496	select_input_picture(s);
2497
2498	/* output? */
2499	if(s->new_picture.data[0]){
2500	s->pict_type= s->new_picture.pict_type;
2501	//emms_c();
2502	//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2503	MPV_frame_start(s, avctx);
2504
2505	encode_picture(s, s->picture_number);
2506
2507	avctx->real_pict_num = s->picture_number;
2508	avctx->header_bits = s->header_bits;
2509	avctx->mv_bits = s->mv_bits;
2510	avctx->misc_bits = s->misc_bits;
2511	avctx->i_tex_bits = s->i_tex_bits;
2512	avctx->p_tex_bits = s->p_tex_bits;
2513	avctx->i_count = s->i_count;
2514	avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2515	avctx->skip_count = s->skip_count;
2516
2517	MPV_frame_end(s);
2518
2519	if (s->out_format == FMT_MJPEG)
2520	mjpeg_picture_trailer(s);
2521
2522	if(s->flags&CODEC_FLAG_PASS1)
2523	ff_write_pass1_stats(s);
2524
2525	for(i=0; i<4; i++){
2526	s->current_picture_ptr->error[i]= s->current_picture.error[i];
2527	avctx->error[i] += s->current_picture_ptr->error[i];
2528	}
2529
2530	if(s->flags&CODEC_FLAG_PASS1)
2531	assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2532	flush_put_bits(&s->pb);
2533	s->frame_bits = put_bits_count(&s->pb);
2534
2535	stuffing_count= ff_vbv_update(s, s->frame_bits);
2536	if(stuffing_count){
2537	if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2538	av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2539	return -1;
2540	}
2541
2542	switch(s->codec_id){
2543	case CODEC_ID_MPEG1VIDEO:
2544	case CODEC_ID_MPEG2VIDEO:
2545	while(stuffing_count--){
2546	put_bits(&s->pb, 8, 0);
2547	}
2548	break;
2549	case CODEC_ID_MPEG4:
2550	put_bits(&s->pb, 16, 0);
2551	put_bits(&s->pb, 16, 0x1C3);
2552	stuffing_count -= 4;
2553	while(stuffing_count--){
2554	put_bits(&s->pb, 8, 0xFF);
2555	}
2556	break;
2557	default:
2558	av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2559	}
2560	flush_put_bits(&s->pb);
2561	s->frame_bits = put_bits_count(&s->pb);
2562	}
2563
2564	/* update mpeg1/2 vbv_delay for CBR */
2565	if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2566	&& 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2567	int vbv_delay;
2568
2569	assert(s->repeat_first_field==0);
2570
2571	vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2572	assert(vbv_delay < 0xFFFF);
2573
2574	s->vbv_delay_ptr[0] &= 0xF8;
2575	s->vbv_delay_ptr[0] \|= vbv_delay>>13;
2576	s->vbv_delay_ptr[1] = vbv_delay>>5;
2577	s->vbv_delay_ptr[2] &= 0x07;
2578	s->vbv_delay_ptr[2] \|= vbv_delay<<3;
2579	}
2580	s->total_bits += s->frame_bits;
2581	avctx->frame_bits = s->frame_bits;
2582	}else{
2583	assert((pbBufPtr(&s->pb) == s->pb.buf));
2584	s->frame_bits=0;
2585	}
2586	assert((s->frame_bits&7)==0);
2587
2588	return s->frame_bits/8;
2589	}
2590
2591	#endif //CONFIG_ENCODERS
2592
2593	static inline void gmc1_motion(MpegEncContext *s,
2594	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
2595	uint8_t **ref_picture)
2596	{
2597	uint8_t *ptr;
2598	int offset, src_x, src_y, linesize, uvlinesize;
2599	int motion_x, motion_y;
2600	int emu=0;
2601
2602	motion_x= s->sprite_offset[0][0];
2603	motion_y= s->sprite_offset[0][1];
2604	src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2605	src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2606	motion_x<<=(3-s->sprite_warping_accuracy);
2607	motion_y<<=(3-s->sprite_warping_accuracy);
2608	src_x = clip(src_x, -16, s->width);
2609	if (src_x == s->width)
2610	motion_x =0;
2611	src_y = clip(src_y, -16, s->height);
2612	if (src_y == s->height)
2613	motion_y =0;
2614
2615	linesize = s->linesize;
2616	uvlinesize = s->uvlinesize;
2617
2618	ptr = ref_picture[0] + (src_y * linesize) + src_x;
2619
2620	if(s->flags&CODEC_FLAG_EMU_EDGE){
2621	if( (unsigned)src_x >= s->h_edge_pos - 17
2622	\|\| (unsigned)src_y >= s->v_edge_pos - 17){
2623	ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2624	ptr= s->edge_emu_buffer;
2625	}
2626	}
2627
2628	if((motion_x\|motion_y)&7){
2629	s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2630	s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2631	}else{
2632	int dxy;
2633
2634	dxy= ((motion_x>>3)&1) \| ((motion_y>>2)&2);
2635	if (s->no_rounding){
2636	s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2637	}else{
2638	s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2639	}
2640	}
2641
2642	if(s->flags&CODEC_FLAG_GRAY) return;
2643
2644	motion_x= s->sprite_offset[1][0];
2645	motion_y= s->sprite_offset[1][1];
2646	src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2647	src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2648	motion_x<<=(3-s->sprite_warping_accuracy);
2649	motion_y<<=(3-s->sprite_warping_accuracy);
2650	src_x = clip(src_x, -8, s->width>>1);
2651	if (src_x == s->width>>1)
2652	motion_x =0;
2653	src_y = clip(src_y, -8, s->height>>1);
2654	if (src_y == s->height>>1)
2655	motion_y =0;
2656
2657	offset = (src_y * uvlinesize) + src_x;
2658	ptr = ref_picture[1] + offset;
2659	if(s->flags&CODEC_FLAG_EMU_EDGE){
2660	if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2661	\|\| (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2662	ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2663	ptr= s->edge_emu_buffer;
2664	emu=1;
2665	}
2666	}
2667	s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2668
2669	ptr = ref_picture[2] + offset;
2670	if(emu){
2671	ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2672	ptr= s->edge_emu_buffer;
2673	}
2674	s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2675
2676	return;
2677	}
2678
2679	static inline void gmc_motion(MpegEncContext *s,
2680	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
2681	uint8_t **ref_picture)
2682	{
2683	uint8_t *ptr;
2684	int linesize, uvlinesize;
2685	const int a= s->sprite_warping_accuracy;
2686	int ox, oy;
2687
2688	linesize = s->linesize;
2689	uvlinesize = s->uvlinesize;
2690
2691	ptr = ref_picture[0];
2692
2693	ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]s->mb_x16 + s->sprite_delta[0][1]s->mb_y16;
2694	oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]s->mb_x16 + s->sprite_delta[1][1]s->mb_y16;
2695
2696	s->dsp.gmc(dest_y, ptr, linesize, 16,
2697	ox,
2698	oy,
2699	s->sprite_delta[0][0], s->sprite_delta[0][1],
2700	s->sprite_delta[1][0], s->sprite_delta[1][1],
2701	a+1, (1<<(2*a+1)) - s->no_rounding,
2702	s->h_edge_pos, s->v_edge_pos);
2703	s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2704	ox + s->sprite_delta[0][0]*8,
2705	oy + s->sprite_delta[1][0]*8,
2706	s->sprite_delta[0][0], s->sprite_delta[0][1],
2707	s->sprite_delta[1][0], s->sprite_delta[1][1],
2708	a+1, (1<<(2*a+1)) - s->no_rounding,
2709	s->h_edge_pos, s->v_edge_pos);
2710
2711	if(s->flags&CODEC_FLAG_GRAY) return;
2712
2713	ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]s->mb_x8 + s->sprite_delta[0][1]s->mb_y8;
2714	oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]s->mb_x8 + s->sprite_delta[1][1]s->mb_y8;
2715
2716	ptr = ref_picture[1];
2717	s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2718	ox,
2719	oy,
2720	s->sprite_delta[0][0], s->sprite_delta[0][1],
2721	s->sprite_delta[1][0], s->sprite_delta[1][1],
2722	a+1, (1<<(2*a+1)) - s->no_rounding,
2723	s->h_edge_pos>>1, s->v_edge_pos>>1);
2724
2725	ptr = ref_picture[2];
2726	s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2727	ox,
2728	oy,
2729	s->sprite_delta[0][0], s->sprite_delta[0][1],
2730	s->sprite_delta[1][0], s->sprite_delta[1][1],
2731	a+1, (1<<(2*a+1)) - s->no_rounding,
2732	s->h_edge_pos>>1, s->v_edge_pos>>1);
2733	}
2734
2735	/**
2736	* Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2737	* @param buf destination buffer
2738	* @param src source buffer
2739	* @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2740	* @param block_w width of block
2741	* @param block_h height of block
2742	* @param src_x x coordinate of the top left sample of the block in the source buffer
2743	* @param src_y y coordinate of the top left sample of the block in the source buffer
2744	* @param w width of the source buffer
2745	* @param h height of the source buffer
2746	*/
2747	void ff_emulated_edge_mc(uint8_t buf, uint8_t src, int linesize, int block_w, int block_h,
2748	int src_x, int src_y, int w, int h){
2749	int x, y;
2750	int start_y, start_x, end_y, end_x;
2751
2752	if(src_y>= h){
2753	src+= (h-1-src_y)*linesize;
2754	src_y=h-1;
2755	}else if(src_y<=-block_h){
2756	src+= (1-block_h-src_y)*linesize;
2757	src_y=1-block_h;
2758	}
2759	if(src_x>= w){
2760	src+= (w-1-src_x);
2761	src_x=w-1;
2762	}else if(src_x<=-block_w){
2763	src+= (1-block_w-src_x);
2764	src_x=1-block_w;
2765	}
2766
2767	start_y= FFMAX(0, -src_y);
2768	start_x= FFMAX(0, -src_x);
2769	end_y= FFMIN(block_h, h-src_y);
2770	end_x= FFMIN(block_w, w-src_x);
2771
2772	// copy existing part
2773	for(y=start_y; y<end_y; y++){
2774	for(x=start_x; x<end_x; x++){
2775	buf[x + ylinesize]= src[x + ylinesize];
2776	}
2777	}
2778
2779	//top
2780	for(y=0; y<start_y; y++){
2781	for(x=start_x; x<end_x; x++){
2782	buf[x + ylinesize]= buf[x + start_ylinesize];
2783	}
2784	}
2785
2786	//bottom
2787	for(y=end_y; y<block_h; y++){
2788	for(x=start_x; x<end_x; x++){
2789	buf[x + ylinesize]= buf[x + (end_y-1)linesize];
2790	}
2791	}
2792
2793	for(y=0; y<block_h; y++){
2794	//left
2795	for(x=0; x<start_x; x++){
2796	buf[x + ylinesize]= buf[start_x + ylinesize];
2797	}
2798
2799	//right
2800	for(x=end_x; x<block_w; x++){
2801	buf[x + ylinesize]= buf[end_x - 1 + ylinesize];
2802	}
2803	}
2804	}
2805
2806	static inline int hpel_motion(MpegEncContext *s,
2807	uint8_t dest, uint8_t src,
2808	int field_based, int field_select,
2809	int src_x, int src_y,
2810	int width, int height, int stride,
2811	int h_edge_pos, int v_edge_pos,
2812	int w, int h, op_pixels_func *pix_op,
2813	int motion_x, int motion_y)
2814	{
2815	int dxy;
2816	int emu=0;
2817
2818	dxy = ((motion_y & 1) << 1) \| (motion_x & 1);
2819	src_x += motion_x >> 1;
2820	src_y += motion_y >> 1;
2821
2822	/* WARNING: do no forget half pels */
2823	src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2824	if (src_x == width)
2825	dxy &= ~1;
2826	src_y = clip(src_y, -16, height);
2827	if (src_y == height)
2828	dxy &= ~2;
2829	src += src_y * stride + src_x;
2830
2831	if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2832	if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2833	\|\| (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2834	ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2835	src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2836	src= s->edge_emu_buffer;
2837	emu=1;
2838	}
2839	}
2840	if(field_select)
2841	src += s->linesize;
2842	pix_op[dxy](dest, src, stride, h);
2843	return emu;
2844	}
2845
2846	static inline int hpel_motion_lowres(MpegEncContext *s,
2847	uint8_t dest, uint8_t src,
2848	int field_based, int field_select,
2849	int src_x, int src_y,
2850	int width, int height, int stride,
2851	int h_edge_pos, int v_edge_pos,
2852	int w, int h, h264_chroma_mc_func *pix_op,
2853	int motion_x, int motion_y)
2854	{
2855	const int lowres= s->avctx->lowres;
2856	const int s_mask= (2<<lowres)-1;
2857	int emu=0;
2858	int sx, sy;
2859
2860	if(s->quarter_sample){
2861	motion_x/=2;
2862	motion_y/=2;
2863	}
2864
2865	sx= motion_x & s_mask;
2866	sy= motion_y & s_mask;
2867	src_x += motion_x >> (lowres+1);
2868	src_y += motion_y >> (lowres+1);
2869
2870	src += src_y * stride + src_x;
2871
2872	if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2873	\|\| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2874	ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2875	src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2876	src= s->edge_emu_buffer;
2877	emu=1;
2878	}
2879
2880	sx <<= 2 - lowres;
2881	sy <<= 2 - lowres;
2882	if(field_select)
2883	src += s->linesize;
2884	pix_op[lowres](dest, src, stride, h, sx, sy);
2885	return emu;
2886	}
2887
2888	/* apply one mpeg motion vector to the three components */
2889	static always_inline void mpeg_motion(MpegEncContext *s,
2890	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
2891	int field_based, int bottom_field, int field_select,
2892	uint8_t *ref_picture, op_pixels_func (pix_op)[4],
2893	int motion_x, int motion_y, int h)
2894	{
2895	uint8_t ptr_y, ptr_cb, *ptr_cr;
2896	int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2897
2898	#if 0
2899	if(s->quarter_sample)
2900	{
2901	motion_x>>=1;
2902	motion_y>>=1;
2903	}
2904	#endif
2905
2906	v_edge_pos = s->v_edge_pos >> field_based;
2907	linesize = s->current_picture.linesize[0] << field_based;
2908	uvlinesize = s->current_picture.linesize[1] << field_based;
2909
2910	dxy = ((motion_y & 1) << 1) \| (motion_x & 1);
2911	src_x = s->mb_x* 16 + (motion_x >> 1);
2912	src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2913
2914	if (s->out_format == FMT_H263) {
2915	if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2916	mx = (motion_x>>1)\|(motion_x&1);
2917	my = motion_y >>1;
2918	uvdxy = ((my & 1) << 1) \| (mx & 1);
2919	uvsrc_x = s->mb_x* 8 + (mx >> 1);
2920	uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2921	}else{
2922	uvdxy = dxy \| (motion_y & 2) \| ((motion_x & 2) >> 1);
2923	uvsrc_x = src_x>>1;
2924	uvsrc_y = src_y>>1;
2925	}
2926	}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2927	mx = motion_x / 4;
2928	my = motion_y / 4;
2929	uvdxy = 0;
2930	uvsrc_x = s->mb_x*8 + mx;
2931	uvsrc_y = s->mb_y*8 + my;
2932	} else {
2933	if(s->chroma_y_shift){
2934	mx = motion_x / 2;
2935	my = motion_y / 2;
2936	uvdxy = ((my & 1) << 1) \| (mx & 1);
2937	uvsrc_x = s->mb_x* 8 + (mx >> 1);
2938	uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2939	} else {
2940	if(s->chroma_x_shift){
2941	//Chroma422
2942	mx = motion_x / 2;
2943	uvdxy = ((motion_y & 1) << 1) \| (mx & 1);
2944	uvsrc_x = s->mb_x* 8 + (mx >> 1);
2945	uvsrc_y = src_y;
2946	} else {
2947	//Chroma444
2948	uvdxy = dxy;
2949	uvsrc_x = src_x;
2950	uvsrc_y = src_y;
2951	}
2952	}
2953	}
2954
2955	ptr_y = ref_picture[0] + src_y * linesize + src_x;
2956	ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2957	ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2958
2959	if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2960	\|\| (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2961	if(s->codec_id == CODEC_ID_MPEG2VIDEO \|\|
2962	s->codec_id == CODEC_ID_MPEG1VIDEO){
2963	av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2964	return ;
2965	}
2966	ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2967	src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2968	ptr_y = s->edge_emu_buffer;
2969	if(!(s->flags&CODEC_FLAG_GRAY)){
2970	uint8_t uvbuf= s->edge_emu_buffer+18s->linesize;
2971	ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2972	uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2973	ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2974	uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2975	ptr_cb= uvbuf;
2976	ptr_cr= uvbuf+16;
2977	}
2978	}
2979
2980	if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2981	dest_y += s->linesize;
2982	dest_cb+= s->uvlinesize;
2983	dest_cr+= s->uvlinesize;
2984	}
2985
2986	if(field_select){
2987	ptr_y += s->linesize;
2988	ptr_cb+= s->uvlinesize;
2989	ptr_cr+= s->uvlinesize;
2990	}
2991
2992	pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2993
2994	if(!(s->flags&CODEC_FLAG_GRAY)){
2995	pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2996	pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2997	}
2998	#if defined(CONFIG_H261_ENCODER) \|\| defined(CONFIG_H261_DECODER)
2999	if(s->out_format == FMT_H261){
3000	ff_h261_loop_filter(s);
3001	}
3002	#endif
3003	}
3004
3005	/* apply one mpeg motion vector to the three components */
3006	static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3007	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
3008	int field_based, int bottom_field, int field_select,
3009	uint8_t *ref_picture, h264_chroma_mc_func pix_op,
3010	int motion_x, int motion_y, int h)
3011	{
3012	uint8_t ptr_y, ptr_cb, *ptr_cr;
3013	int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3014	const int lowres= s->avctx->lowres;
3015	const int block_s= 8>>lowres;
3016	const int s_mask= (2<<lowres)-1;
3017	const int h_edge_pos = s->h_edge_pos >> lowres;
3018	const int v_edge_pos = s->v_edge_pos >> lowres;
3019	linesize = s->current_picture.linesize[0] << field_based;
3020	uvlinesize = s->current_picture.linesize[1] << field_based;
3021
3022	if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3023	motion_x/=2;
3024	motion_y/=2;
3025	}
3026
3027	if(field_based){
3028	motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3029	}
3030
3031	sx= motion_x & s_mask;
3032	sy= motion_y & s_mask;
3033	src_x = s->mb_x2block_s + (motion_x >> (lowres+1));
3034	src_y =(s->mb_y2block_s>>field_based) + (motion_y >> (lowres+1));
3035
3036	if (s->out_format == FMT_H263) {
3037	uvsx = ((motion_x>>1) & s_mask) \| (sx&1);
3038	uvsy = ((motion_y>>1) & s_mask) \| (sy&1);
3039	uvsrc_x = src_x>>1;
3040	uvsrc_y = src_y>>1;
3041	}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3042	mx = motion_x / 4;
3043	my = motion_y / 4;
3044	uvsx = (2*mx) & s_mask;
3045	uvsy = (2*my) & s_mask;
3046	uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3047	uvsrc_y = s->mb_y*block_s + (my >> lowres);
3048	} else {
3049	mx = motion_x / 2;
3050	my = motion_y / 2;
3051	uvsx = mx & s_mask;
3052	uvsy = my & s_mask;
3053	uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3054	uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3055	}
3056
3057	ptr_y = ref_picture[0] + src_y * linesize + src_x;
3058	ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3059	ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3060
3061	if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3062	\|\| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3063	ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3064	src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3065	ptr_y = s->edge_emu_buffer;
3066	if(!(s->flags&CODEC_FLAG_GRAY)){
3067	uint8_t uvbuf= s->edge_emu_buffer+18s->linesize;
3068	ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3069	uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3070	ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3071	uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3072	ptr_cb= uvbuf;
3073	ptr_cr= uvbuf+16;
3074	}
3075	}
3076
3077	if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3078	dest_y += s->linesize;
3079	dest_cb+= s->uvlinesize;
3080	dest_cr+= s->uvlinesize;
3081	}
3082
3083	if(field_select){
3084	ptr_y += s->linesize;
3085	ptr_cb+= s->uvlinesize;
3086	ptr_cr+= s->uvlinesize;
3087	}
3088
3089	sx <<= 2 - lowres;
3090	sy <<= 2 - lowres;
3091	pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3092
3093	if(!(s->flags&CODEC_FLAG_GRAY)){
3094	uvsx <<= 2 - lowres;
3095	uvsy <<= 2 - lowres;
3096	pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3097	pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3098	}
3099	//FIXME h261 lowres loop filter
3100	}
3101
3102	//FIXME move to dsputil, avg variant, 16x16 version
3103	static inline void put_obmc(uint8_t dst, uint8_t src[5], int stride){
3104	int x;
3105	uint8_t * const top = src[1];
3106	uint8_t * const left = src[2];
3107	uint8_t * const mid = src[0];
3108	uint8_t * const right = src[3];
3109	uint8_t * const bottom= src[4];
3110	#define OBMC_FILTER(x, t, l, m, r, b)\
3111	dst[x]= (ttop[x] + lleft[x] + mmid[x] + rright[x] + b*bottom[x] + 4)>>3
3112	#define OBMC_FILTER4(x, t, l, m, r, b)\
3113	OBMC_FILTER(x , t, l, m, r, b);\
3114	OBMC_FILTER(x+1 , t, l, m, r, b);\
3115	OBMC_FILTER(x +stride, t, l, m, r, b);\
3116	OBMC_FILTER(x+1+stride, t, l, m, r, b);
3117
3118	x=0;
3119	OBMC_FILTER (x , 2, 2, 4, 0, 0);
3120	OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3121	OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3122	OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3123	OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3124	OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3125	x+= stride;
3126	OBMC_FILTER (x , 1, 2, 5, 0, 0);
3127	OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3128	OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3129	OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3130	x+= stride;
3131	OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3132	OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3133	OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3134	OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3135	x+= 2*stride;
3136	OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3137	OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3138	OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3139	OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3140	x+= 2*stride;
3141	OBMC_FILTER (x , 0, 2, 5, 0, 1);
3142	OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3143	OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3144	OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3145	OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3146	OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3147	x+= stride;
3148	OBMC_FILTER (x , 0, 2, 4, 0, 2);
3149	OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3150	OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3151	OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3152	}
3153
3154	/* obmc for 1 8x8 luma block */
3155	static inline void obmc_motion(MpegEncContext *s,
3156	uint8_t dest, uint8_t src,
3157	int src_x, int src_y,
3158	op_pixels_func *pix_op,
3159	int16_t mv[5][2]/* mid top left right bottom*/)
3160	#define MID 0
3161	{
3162	int i;
3163	uint8_t *ptr[5];
3164
3165	assert(s->quarter_sample==0);
3166
3167	for(i=0; i<5; i++){
3168	if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3169	ptr[i]= ptr[MID];
3170	}else{
3171	ptr[i]= s->obmc_scratchpad + 8(i&1) + s->linesize8*(i>>1);
3172	hpel_motion(s, ptr[i], src, 0, 0,
3173	src_x, src_y,
3174	s->width, s->height, s->linesize,
3175	s->h_edge_pos, s->v_edge_pos,
3176	8, 8, pix_op,
3177	mv[i][0], mv[i][1]);
3178	}
3179	}
3180
3181	put_obmc(dest, ptr, s->linesize);
3182	}
3183
3184	static inline void qpel_motion(MpegEncContext *s,
3185	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
3186	int field_based, int bottom_field, int field_select,
3187	uint8_t *ref_picture, op_pixels_func (pix_op)[4],
3188	qpel_mc_func (*qpix_op)[16],
3189	int motion_x, int motion_y, int h)
3190	{
3191	uint8_t ptr_y, ptr_cb, *ptr_cr;
3192	int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3193
3194	dxy = ((motion_y & 3) << 2) \| (motion_x & 3);
3195	src_x = s->mb_x * 16 + (motion_x >> 2);
3196	src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3197
3198	v_edge_pos = s->v_edge_pos >> field_based;
3199	linesize = s->linesize << field_based;
3200	uvlinesize = s->uvlinesize << field_based;
3201
3202	if(field_based){
3203	mx= motion_x/2;
3204	my= motion_y>>1;
3205	}else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3206	static const int rtab[8]= {0,0,1,1,0,0,0,1};
3207	mx= (motion_x>>1) + rtab[motion_x&7];
3208	my= (motion_y>>1) + rtab[motion_y&7];
3209	}else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3210	mx= (motion_x>>1)\|(motion_x&1);
3211	my= (motion_y>>1)\|(motion_y&1);
3212	}else{
3213	mx= motion_x/2;
3214	my= motion_y/2;
3215	}
3216	mx= (mx>>1)\|(mx&1);
3217	my= (my>>1)\|(my&1);
3218
3219	uvdxy= (mx&1) \| ((my&1)<<1);
3220	mx>>=1;
3221	my>>=1;
3222
3223	uvsrc_x = s->mb_x * 8 + mx;
3224	uvsrc_y = s->mb_y * (8 >> field_based) + my;
3225
3226	ptr_y = ref_picture[0] + src_y * linesize + src_x;
3227	ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3228	ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3229
3230	if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3231	\|\| (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3232	ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3233	src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3234	ptr_y= s->edge_emu_buffer;
3235	if(!(s->flags&CODEC_FLAG_GRAY)){
3236	uint8_t uvbuf= s->edge_emu_buffer + 18s->linesize;
3237	ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3238	uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3239	ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3240	uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3241	ptr_cb= uvbuf;
3242	ptr_cr= uvbuf + 16;
3243	}
3244	}
3245
3246	if(!field_based)
3247	qpix_op[0][dxy](dest_y, ptr_y, linesize);
3248	else{
3249	if(bottom_field){
3250	dest_y += s->linesize;
3251	dest_cb+= s->uvlinesize;
3252	dest_cr+= s->uvlinesize;
3253	}
3254
3255	if(field_select){
3256	ptr_y += s->linesize;
3257	ptr_cb += s->uvlinesize;
3258	ptr_cr += s->uvlinesize;
3259	}
3260	//damn interlaced mode
3261	//FIXME boundary mirroring is not exactly correct here
3262	qpix_op[1][dxy](dest_y , ptr_y , linesize);
3263	qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3264	}
3265	if(!(s->flags&CODEC_FLAG_GRAY)){
3266	pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3267	pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3268	}
3269	}
3270
3271	inline int ff_h263_round_chroma(int x){
3272	if (x >= 0)
3273	return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3274	else {
3275	x = -x;
3276	return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3277	}
3278	}
3279
3280	/**
3281	* h263 chorma 4mv motion compensation.
3282	*/
3283	static inline void chroma_4mv_motion(MpegEncContext *s,
3284	uint8_t dest_cb, uint8_t dest_cr,
3285	uint8_t **ref_picture,
3286	op_pixels_func *pix_op,
3287	int mx, int my){
3288	int dxy, emu=0, src_x, src_y, offset;
3289	uint8_t *ptr;
3290
3291	/* In case of 8X8, we construct a single chroma motion vector
3292	with a special rounding */
3293	mx= ff_h263_round_chroma(mx);
3294	my= ff_h263_round_chroma(my);
3295
3296	dxy = ((my & 1) << 1) \| (mx & 1);
3297	mx >>= 1;
3298	my >>= 1;
3299
3300	src_x = s->mb_x * 8 + mx;
3301	src_y = s->mb_y * 8 + my;
3302	src_x = clip(src_x, -8, s->width/2);
3303	if (src_x == s->width/2)
3304	dxy &= ~1;
3305	src_y = clip(src_y, -8, s->height/2);
3306	if (src_y == s->height/2)
3307	dxy &= ~2;
3308
3309	offset = (src_y * (s->uvlinesize)) + src_x;
3310	ptr = ref_picture[1] + offset;
3311	if(s->flags&CODEC_FLAG_EMU_EDGE){
3312	if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3313	\|\| (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3314	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);
3315	ptr= s->edge_emu_buffer;
3316	emu=1;
3317	}
3318	}
3319	pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3320
3321	ptr = ref_picture[2] + offset;
3322	if(emu){
3323	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);
3324	ptr= s->edge_emu_buffer;
3325	}
3326	pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3327	}
3328
3329	static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3330	uint8_t dest_cb, uint8_t dest_cr,
3331	uint8_t **ref_picture,
3332	h264_chroma_mc_func *pix_op,
3333	int mx, int my){
3334	const int lowres= s->avctx->lowres;
3335	const int block_s= 8>>lowres;
3336	const int s_mask= (2<<lowres)-1;
3337	const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3338	const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3339	int emu=0, src_x, src_y, offset, sx, sy;
3340	uint8_t *ptr;
3341
3342	if(s->quarter_sample){
3343	mx/=2;
3344	my/=2;
3345	}
3346
3347	/* In case of 8X8, we construct a single chroma motion vector
3348	with a special rounding */
3349	mx= ff_h263_round_chroma(mx);
3350	my= ff_h263_round_chroma(my);
3351
3352	sx= mx & s_mask;
3353	sy= my & s_mask;
3354	src_x = s->mb_x*block_s + (mx >> (lowres+1));
3355	src_y = s->mb_y*block_s + (my >> (lowres+1));
3356
3357	offset = src_y * s->uvlinesize + src_x;
3358	ptr = ref_picture[1] + offset;
3359	if(s->flags&CODEC_FLAG_EMU_EDGE){
3360	if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3361	\|\| (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3362	ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3363	ptr= s->edge_emu_buffer;
3364	emu=1;
3365	}
3366	}
3367	sx <<= 2 - lowres;
3368	sy <<= 2 - lowres;
3369	pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3370
3371	ptr = ref_picture[2] + offset;
3372	if(emu){
3373	ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3374	ptr= s->edge_emu_buffer;
3375	}
3376	pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3377	}
3378
3379	static inline void prefetch_motion(MpegEncContext s, uint8_t *pix, int dir){
3380	/* fetch pixels for estimated mv 4 macroblocks ahead
3381	* optimized for 64byte cache lines */
3382	const int shift = s->quarter_sample ? 2 : 1;
3383	const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3384	const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3385	int off= mx + (my + (s->mb_x&3)4)s->linesize + 64;
3386	s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3387	off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3388	s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3389	}
3390
3391	/**
3392	* motion compensation of a single macroblock
3393	* @param s context
3394	* @param dest_y luma destination pointer
3395	* @param dest_cb chroma cb/u destination pointer
3396	* @param dest_cr chroma cr/v destination pointer
3397	* @param dir direction (0->forward, 1->backward)
3398	* @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3399	* @param pic_op halfpel motion compensation function (average or put normally)
3400	* @param pic_op qpel motion compensation function (average or put normally)
3401	* the motion vectors are taken from s->mv and the MV type from s->mv_type
3402	*/
3403	static inline void MPV_motion(MpegEncContext *s,
3404	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
3405	int dir, uint8_t **ref_picture,
3406	op_pixels_func (pix_op)[4], qpel_mc_func (qpix_op)[16])
3407	{
3408	int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3409	int mb_x, mb_y, i;
3410	uint8_t ptr, dest;
3411
3412	mb_x = s->mb_x;
3413	mb_y = s->mb_y;
3414
3415	prefetch_motion(s, ref_picture, dir);
3416
3417	if(s->obmc && s->pict_type != B_TYPE){
3418	int16_t mv_cache[4][4][2];
3419	const int xy= s->mb_x + s->mb_y*s->mb_stride;
3420	const int mot_stride= s->b8_stride;
3421	const int mot_xy= mb_x2 + mb_y2*mot_stride;
3422
3423	assert(!s->mb_skipped);
3424
3425	memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3426	memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3427	memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3428
3429	if(mb_y==0 \|\| IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3430	memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3431	}else{
3432	memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3433	}
3434
3435	if(mb_x==0 \|\| IS_INTRA(s->current_picture.mb_type[xy-1])){
3436	(int32_t)mv_cache[1][0]= (int32_t)mv_cache[1][1];
3437	(int32_t)mv_cache[2][0]= (int32_t)mv_cache[2][1];
3438	}else{
3439	(int32_t)mv_cache[1][0]= (int32_t)s->current_picture.motion_val[0][mot_xy-1];
3440	(int32_t)mv_cache[2][0]= (int32_t)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3441	}
3442
3443	if(mb_x+1>=s->mb_width \|\| IS_INTRA(s->current_picture.mb_type[xy+1])){
3444	(int32_t)mv_cache[1][3]= (int32_t)mv_cache[1][2];
3445	(int32_t)mv_cache[2][3]= (int32_t)mv_cache[2][2];
3446	}else{
3447	(int32_t)mv_cache[1][3]= (int32_t)s->current_picture.motion_val[0][mot_xy+2];
3448	(int32_t)mv_cache[2][3]= (int32_t)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3449	}
3450
3451	mx = 0;
3452	my = 0;
3453	for(i=0;i<4;i++) {
3454	const int x= (i&1)+1;
3455	const int y= (i>>1)+1;
3456	int16_t mv[5][2]= {
3457	{mv_cache[y][x ][0], mv_cache[y][x ][1]},
3458	{mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3459	{mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3460	{mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3461	{mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3462	//FIXME cleanup
3463	obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3464	ref_picture[0],
3465	mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3466	pix_op[1],
3467	mv);
3468
3469	mx += mv[0][0];
3470	my += mv[0][1];
3471	}
3472	if(!(s->flags&CODEC_FLAG_GRAY))
3473	chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3474
3475	return;
3476	}
3477
3478	switch(s->mv_type) {
3479	case MV_TYPE_16X16:
3480	if(s->mcsel){
3481	if(s->real_sprite_warping_points==1){
3482	gmc1_motion(s, dest_y, dest_cb, dest_cr,
3483	ref_picture);
3484	}else{
3485	gmc_motion(s, dest_y, dest_cb, dest_cr,
3486	ref_picture);
3487	}
3488	}else if(s->quarter_sample){
3489	qpel_motion(s, dest_y, dest_cb, dest_cr,
3490	0, 0, 0,
3491	ref_picture, pix_op, qpix_op,
3492	s->mv[dir][0][0], s->mv[dir][0][1], 16);
3493	}else if(s->mspel){
3494	ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3495	ref_picture, pix_op,
3496	s->mv[dir][0][0], s->mv[dir][0][1], 16);
3497	}else
3498	{
3499	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3500	0, 0, 0,
3501	ref_picture, pix_op,
3502	s->mv[dir][0][0], s->mv[dir][0][1], 16);
3503	}
3504	break;
3505	case MV_TYPE_8X8:
3506	mx = 0;
3507	my = 0;
3508	if(s->quarter_sample){
3509	for(i=0;i<4;i++) {
3510	motion_x = s->mv[dir][i][0];
3511	motion_y = s->mv[dir][i][1];
3512
3513	dxy = ((motion_y & 3) << 2) \| (motion_x & 3);
3514	src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3515	src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3516
3517	/* WARNING: do no forget half pels */
3518	src_x = clip(src_x, -16, s->width);
3519	if (src_x == s->width)
3520	dxy &= ~3;
3521	src_y = clip(src_y, -16, s->height);
3522	if (src_y == s->height)
3523	dxy &= ~12;
3524
3525	ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3526	if(s->flags&CODEC_FLAG_EMU_EDGE){
3527	if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3528	\|\| (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3529	ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
3530	ptr= s->edge_emu_buffer;
3531	}
3532	}
3533	dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3534	qpix_op[1][dxy](dest, ptr, s->linesize);
3535
3536	mx += s->mv[dir][i][0]/2;
3537	my += s->mv[dir][i][1]/2;
3538	}
3539	}else{
3540	for(i=0;i<4;i++) {
3541	hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3542	ref_picture[0], 0, 0,
3543	mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3544	s->width, s->height, s->linesize,
3545	s->h_edge_pos, s->v_edge_pos,
3546	8, 8, pix_op[1],
3547	s->mv[dir][i][0], s->mv[dir][i][1]);
3548
3549	mx += s->mv[dir][i][0];
3550	my += s->mv[dir][i][1];
3551	}
3552	}
3553
3554	if(!(s->flags&CODEC_FLAG_GRAY))
3555	chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3556	break;
3557	case MV_TYPE_FIELD:
3558	if (s->picture_structure == PICT_FRAME) {
3559	if(s->quarter_sample){
3560	for(i=0; i<2; i++){
3561	qpel_motion(s, dest_y, dest_cb, dest_cr,
3562	1, i, s->field_select[dir][i],
3563	ref_picture, pix_op, qpix_op,
3564	s->mv[dir][i][0], s->mv[dir][i][1], 8);
3565	}
3566	}else{
3567	/* top field */
3568	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3569	1, 0, s->field_select[dir][0],
3570	ref_picture, pix_op,
3571	s->mv[dir][0][0], s->mv[dir][0][1], 8);
3572	/* bottom field */
3573	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3574	1, 1, s->field_select[dir][1],
3575	ref_picture, pix_op,
3576	s->mv[dir][1][0], s->mv[dir][1][1], 8);
3577	}
3578	} else {
3579	if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3580	ref_picture= s->current_picture_ptr->data;
3581	}
3582
3583	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3584	0, 0, s->field_select[dir][0],
3585	ref_picture, pix_op,
3586	s->mv[dir][0][0], s->mv[dir][0][1], 16);
3587	}
3588	break;
3589	case MV_TYPE_16X8:
3590	for(i=0; i<2; i++){
3591	uint8_t ** ref2picture;
3592
3593	if(s->picture_structure == s->field_select[dir][i] + 1 \|\| s->pict_type == B_TYPE \|\| s->first_field){
3594	ref2picture= ref_picture;
3595	}else{
3596	ref2picture= s->current_picture_ptr->data;
3597	}
3598
3599	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3600	0, 0, s->field_select[dir][i],
3601	ref2picture, pix_op,
3602	s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3603
3604	dest_y += 16*s->linesize;
3605	dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3606	dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3607	}
3608	break;
3609	case MV_TYPE_DMV:
3610	if(s->picture_structure == PICT_FRAME){
3611	for(i=0; i<2; i++){
3612	int j;
3613	for(j=0; j<2; j++){
3614	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3615	1, j, j^i,
3616	ref_picture, pix_op,
3617	s->mv[dir][2i + j][0], s->mv[dir][2i + j][1], 8);
3618	}
3619	pix_op = s->dsp.avg_pixels_tab;
3620	}
3621	}else{
3622	for(i=0; i<2; i++){
3623	mpeg_motion(s, dest_y, dest_cb, dest_cr,
3624	0, 0, s->picture_structure != i+1,
3625	ref_picture, pix_op,
3626	s->mv[dir][2i][0],s->mv[dir][2i][1],16);
3627
3628	// after put we make avg of the same block
3629	pix_op=s->dsp.avg_pixels_tab;
3630
3631	//opposite parity is always in the same frame if this is second field
3632	if(!s->first_field){
3633	ref_picture = s->current_picture_ptr->data;
3634	}
3635	}
3636	}
3637	break;
3638	default: assert(0);
3639	}
3640	}
3641
3642	/**
3643	* motion compensation of a single macroblock
3644	* @param s context
3645	* @param dest_y luma destination pointer
3646	* @param dest_cb chroma cb/u destination pointer
3647	* @param dest_cr chroma cr/v destination pointer
3648	* @param dir direction (0->forward, 1->backward)
3649	* @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3650	* @param pic_op halfpel motion compensation function (average or put normally)
3651	* the motion vectors are taken from s->mv and the MV type from s->mv_type
3652	*/
3653	static inline void MPV_motion_lowres(MpegEncContext *s,
3654	uint8_t dest_y, uint8_t dest_cb, uint8_t *dest_cr,
3655	int dir, uint8_t **ref_picture,
3656	h264_chroma_mc_func *pix_op)
3657	{
3658	int mx, my;
3659	int mb_x, mb_y, i;
3660	const int lowres= s->avctx->lowres;
3661	const int block_s= 8>>lowres;
3662
3663	mb_x = s->mb_x;
3664	mb_y = s->mb_y;
3665
3666	switch(s->mv_type) {
3667	case MV_TYPE_16X16:
3668	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3669	0, 0, 0,
3670	ref_picture, pix_op,
3671	s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3672	break;
3673	case MV_TYPE_8X8:
3674	mx = 0;
3675	my = 0;
3676	for(i=0;i<4;i++) {
3677	hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3678	ref_picture[0], 0, 0,
3679	(2mb_x + (i & 1))block_s, (2mb_y + (i >>1))block_s,
3680	s->width, s->height, s->linesize,
3681	s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3682	block_s, block_s, pix_op,
3683	s->mv[dir][i][0], s->mv[dir][i][1]);
3684
3685	mx += s->mv[dir][i][0];
3686	my += s->mv[dir][i][1];
3687	}
3688
3689	if(!(s->flags&CODEC_FLAG_GRAY))
3690	chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3691	break;
3692	case MV_TYPE_FIELD:
3693	if (s->picture_structure == PICT_FRAME) {
3694	/* top field */
3695	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3696	1, 0, s->field_select[dir][0],
3697	ref_picture, pix_op,
3698	s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3699	/* bottom field */
3700	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3701	1, 1, s->field_select[dir][1],
3702	ref_picture, pix_op,
3703	s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3704	} else {
3705	if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3706	ref_picture= s->current_picture_ptr->data;
3707	}
3708
3709	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3710	0, 0, s->field_select[dir][0],
3711	ref_picture, pix_op,
3712	s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3713	}
3714	break;
3715	case MV_TYPE_16X8:
3716	for(i=0; i<2; i++){
3717	uint8_t ** ref2picture;
3718
3719	if(s->picture_structure == s->field_select[dir][i] + 1 \|\| s->pict_type == B_TYPE \|\| s->first_field){
3720	ref2picture= ref_picture;
3721	}else{
3722	ref2picture= s->current_picture_ptr->data;
3723	}
3724
3725	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3726	0, 0, s->field_select[dir][i],
3727	ref2picture, pix_op,
3728	s->mv[dir][i][0], s->mv[dir][i][1] + 2block_si, block_s);
3729
3730	dest_y += 2block_ss->linesize;
3731	dest_cb+= (2block_s>>s->chroma_y_shift)s->uvlinesize;
3732	dest_cr+= (2block_s>>s->chroma_y_shift)s->uvlinesize;
3733	}
3734	break;
3735	case MV_TYPE_DMV:
3736	if(s->picture_structure == PICT_FRAME){
3737	for(i=0; i<2; i++){
3738	int j;
3739	for(j=0; j<2; j++){
3740	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3741	1, j, j^i,
3742	ref_picture, pix_op,
3743	s->mv[dir][2i + j][0], s->mv[dir][2i + j][1], block_s);
3744	}
3745	pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3746	}
3747	}else{
3748	for(i=0; i<2; i++){
3749	mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3750	0, 0, s->picture_structure != i+1,
3751	ref_picture, pix_op,
3752	s->mv[dir][2i][0],s->mv[dir][2i][1],2*block_s);
3753
3754	// after put we make avg of the same block
3755	pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3756
3757	//opposite parity is always in the same frame if this is second field
3758	if(!s->first_field){
3759	ref_picture = s->current_picture_ptr->data;
3760	}
3761	}
3762	}
3763	break;
3764	default: assert(0);
3765	}
3766	}
3767
3768	/* put block[] to dest[] */
3769	static inline void put_dct(MpegEncContext *s,
3770	DCTELEM block, int i, uint8_t dest, int line_size, int qscale)
3771	{
3772	s->dct_unquantize_intra(s, block, i, qscale);
3773	s->dsp.idct_put (dest, line_size, block);
3774	}
3775
3776	/* add block[] to dest[] */
3777	static inline void add_dct(MpegEncContext *s,
3778	DCTELEM block, int i, uint8_t dest, int line_size)
3779	{
3780	if (s->block_last_index[i] >= 0) {
3781	s->dsp.idct_add (dest, line_size, block);
3782	}
3783	}
3784
3785	static inline void add_dequant_dct(MpegEncContext *s,
3786	DCTELEM block, int i, uint8_t dest, int line_size, int qscale)
3787	{
3788	if (s->block_last_index[i] >= 0) {
3789	s->dct_unquantize_inter(s, block, i, qscale);
3790
3791	s->dsp.idct_add (dest, line_size, block);
3792	}
3793	}
3794
3795	/**
3796	* cleans dc, ac, coded_block for the current non intra MB
3797	*/
3798	void ff_clean_intra_table_entries(MpegEncContext *s)
3799	{
3800	int wrap = s->b8_stride;
3801	int xy = s->block_index[0];
3802
3803	s->dc_val[0][xy ] =
3804	s->dc_val[0][xy + 1 ] =
3805	s->dc_val[0][xy + wrap] =
3806	s->dc_val[0][xy + 1 + wrap] = 1024;
3807	/* ac pred */
3808	memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3809	memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3810	if (s->msmpeg4_version>=3) {
3811	s->coded_block[xy ] =
3812	s->coded_block[xy + 1 ] =
3813	s->coded_block[xy + wrap] =
3814	s->coded_block[xy + 1 + wrap] = 0;
3815	}
3816	/* chroma */
3817	wrap = s->mb_stride;
3818	xy = s->mb_x + s->mb_y * wrap;
3819	s->dc_val[1][xy] =
3820	s->dc_val[2][xy] = 1024;
3821	/* ac pred */
3822	memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3823	memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3824
3825	s->mbintra_table[xy]= 0;
3826	}
3827
3828	/* generic function called after a macroblock has been parsed by the
3829	decoder or after it has been encoded by the encoder.
3830
3831	Important variables used:
3832	s->mb_intra : true if intra macroblock
3833	s->mv_dir : motion vector direction
3834	s->mv_type : motion vector type
3835	s->mv : motion vector
3836	s->interlaced_dct : true if interlaced dct used (mpeg2)
3837	*/
3838	static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3839	{
3840	int mb_x, mb_y;
3841	const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3842	#ifdef HAVE_XVMC
3843	if(s->avctx->xvmc_acceleration){
3844	XVMC_decode_mb(s);//xvmc uses pblocks
3845	return;
3846	}
3847	#endif
3848
3849	mb_x = s->mb_x;
3850	mb_y = s->mb_y;
3851
3852	if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3853	/* save DCT coefficients */
3854	int i,j;
3855	DCTELEM dct = &s->current_picture.dct_coeff[mb_xy64*6];
3856	for(i=0; i<6; i++)
3857	for(j=0; j<64; j++)
3858	*dct++ = block[i][s->dsp.idct_permutation[j]];
3859	}
3860
3861	s->current_picture.qscale_table[mb_xy]= s->qscale;
3862
3863	/* update DC predictors for P macroblocks */
3864	if (!s->mb_intra) {
3865	if (s->h263_pred \|\| s->h263_aic) {
3866	if(s->mbintra_table[mb_xy])
3867	ff_clean_intra_table_entries(s);
3868	} else {
3869	s->last_dc[0] =
3870	s->last_dc[1] =
3871	s->last_dc[2] = 128 << s->intra_dc_precision;
3872	}
3873	}
3874	else if (s->h263_pred \|\| s->h263_aic)
3875	s->mbintra_table[mb_xy]=1;
3876
3877	if ((s->flags&CODEC_FLAG_PSNR) \|\| !(s->encoding && (s->intra_only \|\| s->pict_type==B_TYPE))) { //FIXME precalc
3878	uint8_t dest_y, dest_cb, *dest_cr;
3879	int dct_linesize, dct_offset;
3880	op_pixels_func (*op_pix)[4];
3881	qpel_mc_func (*op_qpix)[16];
3882	const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3883	const int uvlinesize= s->current_picture.linesize[1];
3884	const int readable= s->pict_type != B_TYPE \|\| s->encoding \|\| s->avctx->draw_horiz_band \|\| lowres_flag;
3885	const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3886
3887	/* avoid copy if macroblock skipped in last frame too */
3888	/* skip only during decoding as we might trash the buffers during encoding a bit */
3889	if(!s->encoding){
3890	uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3891	const int age= s->current_picture.age;
3892
3893	assert(age);
3894
3895	if (s->mb_skipped) {
3896	s->mb_skipped= 0;
3897	assert(s->pict_type!=I_TYPE);
3898
3899	(mbskip_ptr) ++; / indicate that this time we skipped it */
3900	if(mbskip_ptr >99) mbskip_ptr= 99;
3901
3902	/* if previous was skipped too, then nothing to do ! */
3903	if (*mbskip_ptr >= age && s->current_picture.reference){
3904	return;
3905	}
3906	} else if(!s->current_picture.reference){
3907	(mbskip_ptr) ++; / increase counter so the age can be compared cleanly */
3908	if(mbskip_ptr >99) mbskip_ptr= 99;
3909	} else{
3910	mbskip_ptr = 0; / not skipped */
3911	}
3912	}
3913
3914	dct_linesize = linesize << s->interlaced_dct;
3915	dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3916
3917	if(readable){
3918	dest_y= s->dest[0];
3919	dest_cb= s->dest[1];
3920	dest_cr= s->dest[2];
3921	}else{
3922	dest_y = s->b_scratchpad;
3923	dest_cb= s->b_scratchpad+16*linesize;
3924	dest_cr= s->b_scratchpad+32*linesize;
3925	}
3926
3927	if (!s->mb_intra) {
3928	/* motion handling */
3929	/* decoding or more than one mb_type (MC was already done otherwise) */
3930	if(!s->encoding){
3931	if(lowres_flag){
3932	h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3933
3934	if (s->mv_dir & MV_DIR_FORWARD) {
3935	MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3936	op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3937	}
3938	if (s->mv_dir & MV_DIR_BACKWARD) {
3939	MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3940	}
3941	}else{
3942	if ((!s->no_rounding) \|\| s->pict_type==B_TYPE){
3943	op_pix = s->dsp.put_pixels_tab;
3944	op_qpix= s->dsp.put_qpel_pixels_tab;
3945	}else{
3946	op_pix = s->dsp.put_no_rnd_pixels_tab;
3947	op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3948	}
3949	if (s->mv_dir & MV_DIR_FORWARD) {
3950	MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3951	op_pix = s->dsp.avg_pixels_tab;
3952	op_qpix= s->dsp.avg_qpel_pixels_tab;
3953	}
3954	if (s->mv_dir & MV_DIR_BACKWARD) {
3955	MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3956	}
3957	}
3958	}
3959
3960	/* skip dequant / idct if we are really late ;) */
3961	if(s->hurry_up>1) goto skip_idct;
3962	if(s->avctx->skip_idct){
3963	if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3964	\|\|(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3965	\|\| s->avctx->skip_idct >= AVDISCARD_ALL)
3966	goto skip_idct;
3967	}
3968
3969	/* add dct residue */
3970	if(s->encoding \|\| !( s->h263_msmpeg4 \|\| s->codec_id==CODEC_ID_MPEG1VIDEO \|\| s->codec_id==CODEC_ID_MPEG2VIDEO
3971	\|\| (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3972	add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3973	add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3974	add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3975	add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3976
3977	if(!(s->flags&CODEC_FLAG_GRAY)){
3978	if (s->chroma_y_shift){
3979	add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3980	add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3981	}else{
3982	dct_linesize >>= 1;
3983	dct_offset >>=1;
3984	add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3985	add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3986	add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3987	add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3988	}
3989	}
3990	} else if(s->codec_id != CODEC_ID_WMV2){
3991	add_dct(s, block[0], 0, dest_y , dct_linesize);
3992	add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3993	add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3994	add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3995
3996	if(!(s->flags&CODEC_FLAG_GRAY)){
3997	if(s->chroma_y_shift){//Chroma420
3998	add_dct(s, block[4], 4, dest_cb, uvlinesize);
3999	add_dct(s, block[5], 5, dest_cr, uvlinesize);
4000	}else{
4001	//chroma422
4002	dct_linesize = uvlinesize << s->interlaced_dct;
4003	dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4004
4005	add_dct(s, block[4], 4, dest_cb, dct_linesize);
4006	add_dct(s, block[5], 5, dest_cr, dct_linesize);
4007	add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4008	add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4009	if(!s->chroma_x_shift){//Chroma444
4010	add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4011	add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4012	add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4013	add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4014	}
4015	}
4016	}//fi gray
4017	}
4018	else{
4019	ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4020	}
4021	} else {
4022	/* dct only in intra block */
4023	if(s->encoding \|\| !(s->codec_id==CODEC_ID_MPEG1VIDEO \|\| s->codec_id==CODEC_ID_MPEG2VIDEO)){
4024	put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4025	put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4026	put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4027	put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4028
4029	if(!(s->flags&CODEC_FLAG_GRAY)){
4030	if(s->chroma_y_shift){
4031	put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4032	put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4033	}else{
4034	dct_offset >>=1;
4035	dct_linesize >>=1;
4036	put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4037	put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4038	put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4039	put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4040	}
4041	}
4042	}else{
4043	s->dsp.idct_put(dest_y , dct_linesize, block[0]);
4044	s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
4045	s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
4046	s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4047
4048	if(!(s->flags&CODEC_FLAG_GRAY)){
4049	if(s->chroma_y_shift){
4050	s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4051	s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4052	}else{
4053
4054	dct_linesize = uvlinesize << s->interlaced_dct;
4055	dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4056
4057	s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4058	s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4059	s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4060	s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4061	if(!s->chroma_x_shift){//Chroma444
4062	s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4063	s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4064	s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4065	s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4066	}
4067	}
4068	}//gray
4069	}
4070	}
4071	skip_idct:
4072	if(!readable){
4073	s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4074	s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4075	s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4076	}
4077	}
4078	}
4079
4080	void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4081	if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4082	else MPV_decode_mb_internal(s, block, 0);
4083	}
4084
4085	#ifdef CONFIG_ENCODERS
4086
4087	static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4088	{
4089	static const char tab[64]=
4090	{3,2,2,1,1,1,1,1,
4091	1,1,1,1,1,1,1,1,
4092	1,1,1,1,1,1,1,1,
4093	0,0,0,0,0,0,0,0,
4094	0,0,0,0,0,0,0,0,
4095	0,0,0,0,0,0,0,0,
4096	0,0,0,0,0,0,0,0,
4097	0,0,0,0,0,0,0,0};
4098	int score=0;
4099	int run=0;
4100	int i;
4101	DCTELEM *block= s->block[n];
4102	const int last_index= s->block_last_index[n];
4103	int skip_dc;
4104
4105	if(threshold<0){
4106	skip_dc=0;
4107	threshold= -threshold;
4108	}else
4109	skip_dc=1;
4110
4111	/* are all which we could set to zero are allready zero? */
4112	if(last_index<=skip_dc - 1) return;
4113
4114	for(i=0; i<=last_index; i++){
4115	const int j = s->intra_scantable.permutated[i];
4116	const int level = ABS(block[j]);
4117	if(level==1){
4118	if(skip_dc && i==0) continue;
4119	score+= tab[run];
4120	run=0;
4121	}else if(level>1){
4122	return;
4123	}else{
4124	run++;
4125	}
4126	}
4127	if(score >= threshold) return;
4128	for(i=skip_dc; i<=last_index; i++){
4129	const int j = s->intra_scantable.permutated[i];
4130	block[j]=0;
4131	}
4132	if(block[0]) s->block_last_index[n]= 0;
4133	else s->block_last_index[n]= -1;
4134	}
4135
4136	static inline void clip_coeffs(MpegEncContext s, DCTELEM block, int last_index)
4137	{
4138	int i;
4139	const int maxlevel= s->max_qcoeff;
4140	const int minlevel= s->min_qcoeff;
4141	int overflow=0;
4142
4143	if(s->mb_intra){
4144	i=1; //skip clipping of intra dc
4145	}else
4146	i=0;
4147
4148	for(;i<=last_index; i++){
4149	const int j= s->intra_scantable.permutated[i];
4150	int level = block[j];
4151
4152	if (level>maxlevel){
4153	level=maxlevel;
4154	overflow++;
4155	}else if(level<minlevel){
4156	level=minlevel;
4157	overflow++;
4158	}
4159
4160	block[j]= level;
4161	}
4162
4163	if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4164	av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4165	}
4166
4167	#endif //CONFIG_ENCODERS
4168
4169	/**
4170	*
4171	* @param h is the normal height, this will be reduced automatically if needed for the last row
4172	*/
4173	void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4174	if (s->avctx->draw_horiz_band) {
4175	AVFrame *src;
4176	int offset[4];
4177
4178	if(s->picture_structure != PICT_FRAME){
4179	h <<= 1;
4180	y <<= 1;
4181	if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4182	}
4183
4184	h= FFMIN(h, s->avctx->height - y);
4185
4186	if(s->pict_type==B_TYPE \|\| s->low_delay \|\| (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4187	src= (AVFrame*)s->current_picture_ptr;
4188	else if(s->last_picture_ptr)
4189	src= (AVFrame*)s->last_picture_ptr;
4190	else
4191	return;
4192
4193	if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4194	offset[0]=
4195	offset[1]=
4196	offset[2]=
4197	offset[3]= 0;
4198	}else{
4199	offset[0]= y * s->linesize;;
4200	offset[1]=
4201	offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4202	offset[3]= 0;
4203	}
4204
4205	emms_c();
4206
4207	s->avctx->draw_horiz_band(s->avctx, src, offset,
4208	y, s->picture_structure, h);
4209	}
4210	}
4211
4212	void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4213	const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4214	const int uvlinesize= s->current_picture.linesize[1];
4215	const int mb_size= 4 - s->avctx->lowres;
4216
4217	s->block_index[0]= s->b8_stride(s->mb_y2 ) - 2 + s->mb_x*2;
4218	s->block_index[1]= s->b8_stride(s->mb_y2 ) - 1 + s->mb_x*2;
4219	s->block_index[2]= s->b8_stride(s->mb_y2 + 1) - 2 + s->mb_x*2;
4220	s->block_index[3]= s->b8_stride(s->mb_y2 + 1) - 1 + s->mb_x*2;
4221	s->block_index[4]= s->mb_stride(s->mb_y + 1) + s->b8_strides->mb_height*2 + s->mb_x - 1;
4222	s->block_index[5]= s->mb_stride(s->mb_y + s->mb_height + 2) + s->b8_strides->mb_height*2 + s->mb_x - 1;
4223	//block_index is not used by mpeg2, so it is not affected by chroma_format
4224
4225	s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4226	s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4227	s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4228
4229	if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4230	{
4231	s->dest[0] += s->mb_y * linesize << mb_size;
4232	s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4233	s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4234	}
4235	}
4236
4237	#ifdef CONFIG_ENCODERS
4238
4239	static void get_vissual_weight(int16_t weight, uint8_t ptr, int stride){
4240	int x, y;
4241	//FIXME optimize
4242	for(y=0; y<8; y++){
4243	for(x=0; x<8; x++){
4244	int x2, y2;
4245	int sum=0;
4246	int sqr=0;
4247	int count=0;
4248
4249	for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4250	for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4251	int v= ptr[x2 + y2*stride];
4252	sum += v;
4253	sqr += v*v;
4254	count++;
4255	}
4256	}
4257	weight[x + 8y]= (36ff_sqrt(countsqr - sumsum)) / count;
4258	}
4259	}
4260	}
4261
4262	static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4263	{
4264	int16_t weight[8][64];
4265	DCTELEM orig[8][64];
4266	const int mb_x= s->mb_x;
4267	const int mb_y= s->mb_y;
4268	int i;
4269	int skip_dct[8];
4270	int dct_offset = s->linesize*8; //default for progressive frames
4271	uint8_t ptr_y, ptr_cb, *ptr_cr;
4272	int wrap_y, wrap_c;
4273
4274	for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4275
4276	if(s->adaptive_quant){
4277	const int last_qp= s->qscale;
4278	const int mb_xy= mb_x + mb_y*s->mb_stride;
4279
4280	s->lambda= s->lambda_table[mb_xy];
4281	update_qscale(s);
4282
4283	if(!(s->flags&CODEC_FLAG_QP_RD)){
4284	s->dquant= s->qscale - last_qp;
4285
4286	if(s->out_format==FMT_H263){
4287	s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4288
4289	if(s->codec_id==CODEC_ID_MPEG4){
4290	if(!s->mb_intra){
4291	if(s->pict_type == B_TYPE){
4292	if(s->dquant&1)
4293	s->dquant= (s->dquant/2)*2;
4294	if(s->mv_dir&MV_DIRECT)
4295	s->dquant= 0;
4296	}
4297	if(s->mv_type==MV_TYPE_8X8)
4298	s->dquant=0;
4299	}
4300	}
4301	}
4302	}
4303	ff_set_qscale(s, last_qp + s->dquant);
4304	}else if(s->flags&CODEC_FLAG_QP_RD)
4305	ff_set_qscale(s, s->qscale + s->dquant);
4306
4307	wrap_y = s->linesize;
4308	wrap_c = s->uvlinesize;
4309	ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4310	ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4311	ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4312
4313	if(mb_x16+16 > s->width \|\| mb_y16+16 > s->height){
4314	uint8_t *ebuf= s->edge_emu_buffer + 32;
4315	ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x16,mb_y16, s->width , s->height);
4316	ptr_y= ebuf;
4317	ff_emulated_edge_mc(ebuf+18wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x8, mb_y*8, s->width>>1, s->height>>1);
4318	ptr_cb= ebuf+18*wrap_y;
4319	ff_emulated_edge_mc(ebuf+18wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x8, mb_y*8, s->width>>1, s->height>>1);
4320	ptr_cr= ebuf+18*wrap_y+8;
4321	}
4322
4323	if (s->mb_intra) {
4324	if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4325	int progressive_score, interlaced_score;
4326
4327	s->interlaced_dct=0;
4328	progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4329	+s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4330
4331	if(progressive_score > 0){
4332	interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4333	+s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4334	if(progressive_score > interlaced_score){
4335	s->interlaced_dct=1;
4336
4337	dct_offset= wrap_y;
4338	wrap_y<<=1;
4339	if (s->chroma_format == CHROMA_422)
4340	wrap_c<<=1;
4341	}
4342	}
4343	}
4344
4345	s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4346	s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4347	s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4348	s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4349
4350	if(s->flags&CODEC_FLAG_GRAY){
4351	skip_dct[4]= 1;
4352	skip_dct[5]= 1;
4353	}else{
4354	s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4355	s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4356	if(!s->chroma_y_shift){ /* 422 */
4357	s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4358	s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4359	}
4360	}
4361	}else{
4362	op_pixels_func (*op_pix)[4];
4363	qpel_mc_func (*op_qpix)[16];
4364	uint8_t dest_y, dest_cb, *dest_cr;
4365
4366	dest_y = s->dest[0];
4367	dest_cb = s->dest[1];
4368	dest_cr = s->dest[2];
4369
4370	if ((!s->no_rounding) \|\| s->pict_type==B_TYPE){
4371	op_pix = s->dsp.put_pixels_tab;
4372	op_qpix= s->dsp.put_qpel_pixels_tab;
4373	}else{
4374	op_pix = s->dsp.put_no_rnd_pixels_tab;
4375	op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4376	}
4377
4378	if (s->mv_dir & MV_DIR_FORWARD) {
4379	MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4380	op_pix = s->dsp.avg_pixels_tab;
4381	op_qpix= s->dsp.avg_qpel_pixels_tab;
4382	}
4383	if (s->mv_dir & MV_DIR_BACKWARD) {
4384	MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4385	}
4386
4387	if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4388	int progressive_score, interlaced_score;
4389
4390	s->interlaced_dct=0;
4391	progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4392	+s->dsp.ildct_cmp[0](s, dest_y + wrap_y8, ptr_y + wrap_y8, wrap_y, 8) - 400;
4393
4394	if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4395
4396	if(progressive_score>0){
4397	interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4398	+s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4399
4400	if(progressive_score > interlaced_score){
4401	s->interlaced_dct=1;
4402
4403	dct_offset= wrap_y;
4404	wrap_y<<=1;
4405	if (s->chroma_format == CHROMA_422)
4406	wrap_c<<=1;
4407	}
4408	}
4409	}
4410
4411	s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4412	s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4413	s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4414	s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4415
4416	if(s->flags&CODEC_FLAG_GRAY){
4417	skip_dct[4]= 1;
4418	skip_dct[5]= 1;
4419	}else{
4420	s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4421	s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4422	if(!s->chroma_y_shift){ /* 422 */
4423	s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4424	s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4425	}
4426	}
4427	/* pre quantization */
4428	if(s->current_picture.mc_mb_var[s->mb_stridemb_y+ mb_x]<2s->qscale*s->qscale){
4429	//FIXME optimize
4430	if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4431	if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4432	if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4433	if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
4434	if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4435	if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4436	if(!s->chroma_y_shift){ /* 422 */
4437	if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1;
4438	if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1;
4439	}
4440	}
4441	}
4442
4443	if(s->avctx->quantizer_noise_shaping){
4444	if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4445	if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4446	if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4447	if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4448	if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4449	if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4450	if(!s->chroma_y_shift){ /* 422 */
4451	if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4452	if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4453	}
4454	memcpy(orig[0], s->block[0], sizeof(DCTELEM)64mb_block_count);
4455	}
4456
4457	/* DCT & quantize */
4458	assert(s->out_format!=FMT_MJPEG \|\| s->qscale==8);
4459	{
4460	for(i=0;i<mb_block_count;i++) {
4461	if(!skip_dct[i]){
4462	int overflow;
4463	s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4464	// FIXME we could decide to change to quantizer instead of clipping
4465	// JS: I don't think that would be a good idea it could lower quality instead
4466	// of improve it. Just INTRADC clipping deserves changes in quantizer
4467	if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4468	}else
4469	s->block_last_index[i]= -1;
4470	}
4471	if(s->avctx->quantizer_noise_shaping){
4472	for(i=0;i<mb_block_count;i++) {
4473	if(!skip_dct[i]){
4474	s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4475	}
4476	}
4477	}
4478
4479	if(s->luma_elim_threshold && !s->mb_intra)
4480	for(i=0; i<4; i++)
4481	dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4482	if(s->chroma_elim_threshold && !s->mb_intra)
4483	for(i=4; i<mb_block_count; i++)
4484	dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4485
4486	if(s->flags & CODEC_FLAG_CBP_RD){
4487	for(i=0;i<mb_block_count;i++) {
4488	if(s->block_last_index[i] == -1)
4489	s->coded_score[i]= INT_MAX/256;
4490	}
4491	}
4492	}
4493
4494	if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4495	s->block_last_index[4]=
4496	s->block_last_index[5]= 0;
4497	s->block[4][0]=
4498	s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4499	}
4500
4501	//non c quantize code returns incorrect block_last_index FIXME
4502	if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4503	for(i=0; i<mb_block_count; i++){
4504	int j;
4505	if(s->block_last_index[i]>0){
4506	for(j=63; j>0; j--){
4507	if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4508	}
4509	s->block_last_index[i]= j;
4510	}
4511	}
4512	}
4513
4514	/* huffman encode */
4515	switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4516	case CODEC_ID_MPEG1VIDEO:
4517	case CODEC_ID_MPEG2VIDEO:
4518	mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4519	case CODEC_ID_MPEG4:
4520	mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4521	case CODEC_ID_MSMPEG4V2:
4522	case CODEC_ID_MSMPEG4V3:
4523	case CODEC_ID_WMV1:
4524	msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4525	case CODEC_ID_WMV2:
4526	ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4527	#ifdef CONFIG_H261_ENCODER
4528	case CODEC_ID_H261:
4529	ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4530	#endif
4531	case CODEC_ID_H263:
4532	case CODEC_ID_H263P:
4533	case CODEC_ID_FLV1:
4534	case CODEC_ID_RV10:
4535	case CODEC_ID_RV20:
4536	h263_encode_mb(s, s->block, motion_x, motion_y); break;
4537	case CODEC_ID_MJPEG:
4538	mjpeg_encode_mb(s, s->block); break;
4539	default:
4540	assert(0);
4541	}
4542	}
4543
4544	static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4545	{
4546	if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
4547	else encode_mb_internal(s, motion_x, motion_y, 16, 8);
4548	}
4549
4550	#endif //CONFIG_ENCODERS
4551
4552	void ff_mpeg_flush(AVCodecContext *avctx){
4553	int i;
4554	MpegEncContext *s = avctx->priv_data;
4555
4556	if(s==NULL \|\| s->picture==NULL)
4557	return;
4558
4559	for(i=0; i<MAX_PICTURE_COUNT; i++){
4560	if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4561	\|\| s->picture[i].type == FF_BUFFER_TYPE_USER))
4562	avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4563	}
4564	s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4565
4566	s->mb_x= s->mb_y= 0;
4567
4568	s->parse_context.state= -1;
4569	s->parse_context.frame_start_found= 0;
4570	s->parse_context.overread= 0;
4571	s->parse_context.overread_index= 0;
4572	s->parse_context.index= 0;
4573	s->parse_context.last_index= 0;
4574	s->bitstream_buffer_size=0;
4575	}
4576
4577	#ifdef CONFIG_ENCODERS
4578	void ff_copy_bits(PutBitContext pb, uint8_t src, int length)
4579	{
4580	const uint16_t srcw= (uint16_t)src;
4581	int words= length>>4;
4582	int bits= length&15;
4583	int i;
4584
4585	if(length==0) return;
4586
4587	if(words < 16){
4588	for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4589	}else if(put_bits_count(pb)&7){
4590	for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4591	}else{
4592	for(i=0; put_bits_count(pb)&31; i++)
4593	put_bits(pb, 8, src[i]);
4594	flush_put_bits(pb);
4595	memcpy(pbBufPtr(pb), src+i, 2*words-i);
4596	skip_put_bytes(pb, 2*words-i);
4597	}
4598
4599	put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4600	}
4601
4602	static inline void copy_context_before_encode(MpegEncContext d, MpegEncContext s, int type){
4603	int i;
4604
4605	memcpy(d->last_mv, s->last_mv, 222*sizeof(int)); //FIXME is memcpy faster then a loop?
4606
4607	/* mpeg1 */
4608	d->mb_skip_run= s->mb_skip_run;
4609	for(i=0; i<3; i++)
4610	d->last_dc[i]= s->last_dc[i];
4611
4612	/* statistics */
4613	d->mv_bits= s->mv_bits;
4614	d->i_tex_bits= s->i_tex_bits;
4615	d->p_tex_bits= s->p_tex_bits;
4616	d->i_count= s->i_count;
4617	d->f_count= s->f_count;
4618	d->b_count= s->b_count;
4619	d->skip_count= s->skip_count;
4620	d->misc_bits= s->misc_bits;
4621	d->last_bits= 0;
4622
4623	d->mb_skipped= 0;
4624	d->qscale= s->qscale;
4625	d->dquant= s->dquant;
4626	}
4627
4628	static inline void copy_context_after_encode(MpegEncContext d, MpegEncContext s, int type){
4629	int i;
4630
4631	memcpy(d->mv, s->mv, 242*sizeof(int));
4632	memcpy(d->last_mv, s->last_mv, 222*sizeof(int)); //FIXME is memcpy faster then a loop?
4633
4634	/* mpeg1 */
4635	d->mb_skip_run= s->mb_skip_run;
4636	for(i=0; i<3; i++)
4637	d->last_dc[i]= s->last_dc[i];
4638
4639	/* statistics */
4640	d->mv_bits= s->mv_bits;
4641	d->i_tex_bits= s->i_tex_bits;
4642	d->p_tex_bits= s->p_tex_bits;
4643	d->i_count= s->i_count;
4644	d->f_count= s->f_count;
4645	d->b_count= s->b_count;
4646	d->skip_count= s->skip_count;
4647	d->misc_bits= s->misc_bits;
4648
4649	d->mb_intra= s->mb_intra;
4650	d->mb_skipped= s->mb_skipped;
4651	d->mv_type= s->mv_type;
4652	d->mv_dir= s->mv_dir;
4653	d->pb= s->pb;
4654	if(s->data_partitioning){
4655	d->pb2= s->pb2;
4656	d->tex_pb= s->tex_pb;
4657	}
4658	d->block= s->block;
4659	for(i=0; i<8; i++)
4660	d->block_last_index[i]= s->block_last_index[i];
4661	d->interlaced_dct= s->interlaced_dct;
4662	d->qscale= s->qscale;
4663	}
4664
4665	static inline void encode_mb_hq(MpegEncContext s, MpegEncContext backup, MpegEncContext *best, int type,
4666	PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4667	int dmin, int next_block, int motion_x, int motion_y)
4668	{
4669	int score;
4670	uint8_t *dest_backup[3];
4671
4672	copy_context_before_encode(s, backup, type);
4673
4674	s->block= s->blocks[*next_block];
4675	s->pb= pb[*next_block];
4676	if(s->data_partitioning){
4677	s->pb2 = pb2 [*next_block];
4678	s->tex_pb= tex_pb[*next_block];
4679	}
4680
4681	if(*next_block){
4682	memcpy(dest_backup, s->dest, sizeof(s->dest));
4683	s->dest[0] = s->rd_scratchpad;
4684	s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4685	s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4686	assert(s->linesize >= 32); //FIXME
4687	}
4688
4689	encode_mb(s, motion_x, motion_y);
4690
4691	score= put_bits_count(&s->pb);
4692	if(s->data_partitioning){
4693	score+= put_bits_count(&s->pb2);
4694	score+= put_bits_count(&s->tex_pb);
4695	}
4696
4697	if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4698	MPV_decode_mb(s, s->block);
4699
4700	score *= s->lambda2;
4701	score += sse_mb(s) << FF_LAMBDA_SHIFT;
4702	}
4703
4704	if(*next_block){
4705	memcpy(s->dest, dest_backup, sizeof(s->dest));
4706	}
4707
4708	if(score<*dmin){
4709	*dmin= score;
4710	*next_block^=1;
4711
4712	copy_context_after_encode(best, s, type);
4713	}
4714	}
4715
4716	static int sse(MpegEncContext s, uint8_t src1, uint8_t *src2, int w, int h, int stride){
4717	uint32_t *sq = squareTbl + 256;
4718	int acc=0;
4719	int x,y;
4720
4721	if(w==16 && h==16)
4722	return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4723	else if(w==8 && h==8)
4724	return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4725
4726	for(y=0; y<h; y++){
4727	for(x=0; x<w; x++){
4728	acc+= sq[src1[x + ystride] - src2[x + ystride]];
4729	}
4730	}
4731
4732	assert(acc>=0);
4733
4734	return acc;
4735	}
4736
4737	static int sse_mb(MpegEncContext *s){
4738	int w= 16;
4739	int h= 16;
4740
4741	if(s->mb_x16 + 16 > s->width ) w= s->width - s->mb_x16;
4742	if(s->mb_y16 + 16 > s->height) h= s->height- s->mb_y16;
4743
4744	if(w==16 && h==16)
4745	if(s->avctx->mb_cmp == FF_CMP_NSSE){
4746	return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x16 + s->mb_ys->linesize*16, s->dest[0], s->linesize, 16)
4747	+s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x8 + s->mb_ys->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4748	+s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x8 + s->mb_ys->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4749	}else{
4750	return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x16 + s->mb_ys->linesize*16, s->dest[0], s->linesize, 16)
4751	+s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x8 + s->mb_ys->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4752	+s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x8 + s->mb_ys->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4753	}
4754	else
4755	return sse(s, s->new_picture.data[0] + s->mb_x16 + s->mb_ys->linesize*16, s->dest[0], w, h, s->linesize)
4756	+sse(s, s->new_picture.data[1] + s->mb_x8 + s->mb_ys->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
4757	+sse(s, s->new_picture.data[2] + s->mb_x8 + s->mb_ys->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
4758	}
4759
4760	static int pre_estimate_motion_thread(AVCodecContext c, void arg){
4761	MpegEncContext *s= arg;
4762
4763
4764	s->me.pre_pass=1;
4765	s->me.dia_size= s->avctx->pre_dia_size;
4766	s->first_slice_line=1;
4767	for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4768	for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4769	ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4770	}
4771	s->first_slice_line=0;
4772	}
4773
4774	s->me.pre_pass=0;
4775
4776	return 0;
4777	}
4778
4779	static int estimate_motion_thread(AVCodecContext c, void arg){
4780	MpegEncContext *s= arg;
4781
4782	s->me.dia_size= s->avctx->dia_size;
4783	s->first_slice_line=1;
4784	for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4785	s->mb_x=0; //for block init below
4786	ff_init_block_index(s);
4787	for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4788	s->block_index[0]+=2;
4789	s->block_index[1]+=2;
4790	s->block_index[2]+=2;
4791	s->block_index[3]+=2;
4792
4793	/* compute motion vector & mb_type and store in context */
4794	if(s->pict_type==B_TYPE)
4795	ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4796	else
4797	ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4798	}
4799	s->first_slice_line=0;
4800	}
4801	return 0;
4802	}
4803
4804	static int mb_var_thread(AVCodecContext c, void arg){
4805	MpegEncContext *s= arg;
4806	int mb_x, mb_y;
4807
4808	for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4809	for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4810	int xx = mb_x * 16;
4811	int yy = mb_y * 16;
4812	uint8_t pix = s->new_picture.data[0] + (yy s->linesize) + xx;
4813	int varc;
4814	int sum = s->dsp.pix_sum(pix, s->linesize);
4815
4816	varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4817
4818	s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4819	s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4820	s->me.mb_var_sum_temp += varc;
4821	}
4822	}
4823	return 0;
4824	}
4825
4826	static void write_slice_end(MpegEncContext *s){
4827	if(s->codec_id==CODEC_ID_MPEG4){
4828	if(s->partitioned_frame){
4829	ff_mpeg4_merge_partitions(s);
4830	}
4831
4832	ff_mpeg4_stuffing(&s->pb);
4833	}else if(s->out_format == FMT_MJPEG){
4834	ff_mjpeg_stuffing(&s->pb);
4835	}
4836
4837	align_put_bits(&s->pb);
4838	flush_put_bits(&s->pb);
4839
4840	if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4841	s->misc_bits+= get_bits_diff(s);
4842	}
4843
4844	static int encode_thread(AVCodecContext c, void arg){
4845	MpegEncContext *s= arg;
4846	int mb_x, mb_y, pdif = 0;
4847	int i, j;
4848	MpegEncContext best_s, backup_s;
4849	uint8_t bit_buf[2][MAX_MB_BYTES];
4850	uint8_t bit_buf2[2][MAX_MB_BYTES];
4851	uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4852	PutBitContext pb[2], pb2[2], tex_pb[2];
4853	//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4854
4855	for(i=0; i<2; i++){
4856	init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4857	init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4858	init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4859	}
4860
4861	s->last_bits= put_bits_count(&s->pb);
4862	s->mv_bits=0;
4863	s->misc_bits=0;
4864	s->i_tex_bits=0;
4865	s->p_tex_bits=0;
4866	s->i_count=0;
4867	s->f_count=0;
4868	s->b_count=0;
4869	s->skip_count=0;
4870
4871	for(i=0; i<3; i++){
4872	/* init last dc values */
4873	/* note: quant matrix value (8) is implied here */
4874	s->last_dc[i] = 128 << s->intra_dc_precision;
4875
4876	s->current_picture.error[i] = 0;
4877	}
4878	s->mb_skip_run = 0;
4879	memset(s->last_mv, 0, sizeof(s->last_mv));
4880
4881	s->last_mv_dir = 0;
4882
4883	switch(s->codec_id){
4884	case CODEC_ID_H263:
4885	case CODEC_ID_H263P:
4886	case CODEC_ID_FLV1:
4887	s->gob_index = ff_h263_get_gob_height(s);
4888	break;
4889	case CODEC_ID_MPEG4:
4890	if(s->partitioned_frame)
4891	ff_mpeg4_init_partitions(s);
4892	break;
4893	}
4894
4895	s->resync_mb_x=0;
4896	s->resync_mb_y=0;
4897	s->first_slice_line = 1;
4898	s->ptr_lastgob = s->pb.buf;
4899	for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4900	// printf("row %d at %X\n", s->mb_y, (int)s);
4901	s->mb_x=0;
4902	s->mb_y= mb_y;
4903
4904	ff_set_qscale(s, s->qscale);
4905	ff_init_block_index(s);
4906
4907	for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4908	int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4909	int mb_type= s->mb_type[xy];
4910	// int d;
4911	int dmin= INT_MAX;
4912	int dir;
4913
4914	if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4915	av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4916	return -1;
4917	}
4918	if(s->data_partitioning){
4919	if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4920	\|\| s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4921	av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4922	return -1;
4923	}
4924	}
4925
4926	s->mb_x = mb_x;
4927	s->mb_y = mb_y; // moved into loop, can get changed by H.261
4928	ff_update_block_index(s);
4929
4930	#ifdef CONFIG_H261_ENCODER
4931	if(s->codec_id == CODEC_ID_H261){
4932	ff_h261_reorder_mb_index(s);
4933	xy= s->mb_y*s->mb_stride + s->mb_x;
4934	mb_type= s->mb_type[xy];
4935	}
4936	#endif
4937
4938	/* write gob / video packet header */
4939	if(s->rtp_mode){
4940	int current_packet_size, is_gob_start;
4941
4942	current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4943
4944	is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4945
4946	if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4947
4948	switch(s->codec_id){
4949	case CODEC_ID_H263:
4950	case CODEC_ID_H263P:
4951	if(!s->h263_slice_structured)
4952	if(s->mb_x \|\| s->mb_y%s->gob_index) is_gob_start=0;
4953	break;
4954	case CODEC_ID_MPEG2VIDEO:
4955	if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4956	case CODEC_ID_MPEG1VIDEO:
4957	if(s->mb_skip_run) is_gob_start=0;
4958	break;
4959	}
4960
4961	if(is_gob_start){
4962	if(s->start_mb_y != mb_y \|\| mb_x!=0){
4963	write_slice_end(s);
4964
4965	if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4966	ff_mpeg4_init_partitions(s);
4967	}
4968	}
4969
4970	assert((put_bits_count(&s->pb)&7) == 0);
4971	current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4972
4973	if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4974	int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4975	int d= 100 / s->avctx->error_rate;
4976	if(r % d == 0){
4977	current_packet_size=0;
4978	#ifndef ALT_BITSTREAM_WRITER
4979	s->pb.buf_ptr= s->ptr_lastgob;
4980	#endif
4981	assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4982	}
4983	}
4984
4985	if (s->avctx->rtp_callback){
4986	int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
4987	s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
4988	}
4989
4990	switch(s->codec_id){
4991	case CODEC_ID_MPEG4:
4992	ff_mpeg4_encode_video_packet_header(s);
4993	ff_mpeg4_clean_buffers(s);
4994	break;
4995	case CODEC_ID_MPEG1VIDEO:
4996	case CODEC_ID_MPEG2VIDEO:
4997	ff_mpeg1_encode_slice_header(s);
4998	ff_mpeg1_clean_buffers(s);
4999	break;
5000	case CODEC_ID_H263:
5001	case CODEC_ID_H263P:
5002	h263_encode_gob_header(s, mb_y);
5003	break;
5004	}
5005
5006	if(s->flags&CODEC_FLAG_PASS1){
5007	int bits= put_bits_count(&s->pb);
5008	s->misc_bits+= bits - s->last_bits;
5009	s->last_bits= bits;
5010	}
5011
5012	s->ptr_lastgob += current_packet_size;
5013	s->first_slice_line=1;
5014	s->resync_mb_x=mb_x;
5015	s->resync_mb_y=mb_y;
5016	}
5017	}
5018
5019	if( (s->resync_mb_x == s->mb_x)
5020	&& s->resync_mb_y+1 == s->mb_y){
5021	s->first_slice_line=0;
5022	}
5023
5024	s->mb_skipped=0;
5025	s->dquant=0; //only for QP_RD
5026
5027	if(mb_type & (mb_type-1) \|\| (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5028	int next_block=0;
5029	int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5030
5031	copy_context_before_encode(&backup_s, s, -1);
5032	backup_s.pb= s->pb;
5033	best_s.data_partitioning= s->data_partitioning;
5034	best_s.partitioned_frame= s->partitioned_frame;
5035	if(s->data_partitioning){
5036	backup_s.pb2= s->pb2;
5037	backup_s.tex_pb= s->tex_pb;
5038	}
5039
5040	if(mb_type&CANDIDATE_MB_TYPE_INTER){
5041	s->mv_dir = MV_DIR_FORWARD;
5042	s->mv_type = MV_TYPE_16X16;
5043	s->mb_intra= 0;
5044	s->mv[0][0][0] = s->p_mv_table[xy][0];
5045	s->mv[0][0][1] = s->p_mv_table[xy][1];
5046	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5047	&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5048	}
5049	if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5050	s->mv_dir = MV_DIR_FORWARD;
5051	s->mv_type = MV_TYPE_FIELD;
5052	s->mb_intra= 0;
5053	for(i=0; i<2; i++){
5054	j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5055	s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5056	s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5057	}
5058	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5059	&dmin, &next_block, 0, 0);
5060	}
5061	if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5062	s->mv_dir = MV_DIR_FORWARD;
5063	s->mv_type = MV_TYPE_16X16;
5064	s->mb_intra= 0;
5065	s->mv[0][0][0] = 0;
5066	s->mv[0][0][1] = 0;
5067	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5068	&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5069	}
5070	if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5071	s->mv_dir = MV_DIR_FORWARD;
5072	s->mv_type = MV_TYPE_8X8;
5073	s->mb_intra= 0;
5074	for(i=0; i<4; i++){
5075	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5076	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5077	}
5078	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5079	&dmin, &next_block, 0, 0);
5080	}
5081	if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5082	s->mv_dir = MV_DIR_FORWARD;
5083	s->mv_type = MV_TYPE_16X16;
5084	s->mb_intra= 0;
5085	s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5086	s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5087	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5088	&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5089	}
5090	if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5091	s->mv_dir = MV_DIR_BACKWARD;
5092	s->mv_type = MV_TYPE_16X16;
5093	s->mb_intra= 0;
5094	s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5095	s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5096	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5097	&dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5098	}
5099	if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5100	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD;
5101	s->mv_type = MV_TYPE_16X16;
5102	s->mb_intra= 0;
5103	s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5104	s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5105	s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5106	s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5107	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5108	&dmin, &next_block, 0, 0);
5109	}
5110	if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5111	int mx= s->b_direct_mv_table[xy][0];
5112	int my= s->b_direct_mv_table[xy][1];
5113
5114	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD \| MV_DIRECT;
5115	s->mb_intra= 0;
5116	ff_mpeg4_set_direct_mv(s, mx, my);
5117	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5118	&dmin, &next_block, mx, my);
5119	}
5120	if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5121	s->mv_dir = MV_DIR_FORWARD;
5122	s->mv_type = MV_TYPE_FIELD;
5123	s->mb_intra= 0;
5124	for(i=0; i<2; i++){
5125	j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5126	s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5127	s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5128	}
5129	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5130	&dmin, &next_block, 0, 0);
5131	}
5132	if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5133	s->mv_dir = MV_DIR_BACKWARD;
5134	s->mv_type = MV_TYPE_FIELD;
5135	s->mb_intra= 0;
5136	for(i=0; i<2; i++){
5137	j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5138	s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5139	s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5140	}
5141	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5142	&dmin, &next_block, 0, 0);
5143	}
5144	if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5145	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD;
5146	s->mv_type = MV_TYPE_FIELD;
5147	s->mb_intra= 0;
5148	for(dir=0; dir<2; dir++){
5149	for(i=0; i<2; i++){
5150	j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5151	s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5152	s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5153	}
5154	}
5155	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5156	&dmin, &next_block, 0, 0);
5157	}
5158	if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5159	s->mv_dir = 0;
5160	s->mv_type = MV_TYPE_16X16;
5161	s->mb_intra= 1;
5162	s->mv[0][0][0] = 0;
5163	s->mv[0][0][1] = 0;
5164	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5165	&dmin, &next_block, 0, 0);
5166	if(s->h263_pred \|\| s->h263_aic){
5167	if(best_s.mb_intra)
5168	s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5169	else
5170	ff_clean_intra_table_entries(s); //old mode?
5171	}
5172	}
5173
5174	if(s->flags & CODEC_FLAG_QP_RD){
5175	if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
5176	const int last_qp= backup_s.qscale;
5177	int dquant, dir, qp, dc[6];
5178	DCTELEM ac[6][16];
5179	const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5180
5181	assert(backup_s.dquant == 0);
5182
5183	//FIXME intra
5184	s->mv_dir= best_s.mv_dir;
5185	s->mv_type = MV_TYPE_16X16;
5186	s->mb_intra= best_s.mb_intra;
5187	s->mv[0][0][0] = best_s.mv[0][0][0];
5188	s->mv[0][0][1] = best_s.mv[0][0][1];
5189	s->mv[1][0][0] = best_s.mv[1][0][0];
5190	s->mv[1][0][1] = best_s.mv[1][0][1];
5191
5192	dir= s->pict_type == B_TYPE ? 2 : 1;
5193	if(last_qp + dir > s->avctx->qmax) dir= -dir;
5194	for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
5195	qp= last_qp + dquant;
5196	if(qp < s->avctx->qmin \|\| qp > s->avctx->qmax)
5197	break;
5198	backup_s.dquant= dquant;
5199	if(s->mb_intra && s->dc_val[0]){
5200	for(i=0; i<6; i++){
5201	dc[i]= s->dc_val[0][ s->block_index[i] ];
5202	memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5203	}
5204	}
5205
5206	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5207	&dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5208	if(best_s.qscale != qp){
5209	if(s->mb_intra && s->dc_val[0]){
5210	for(i=0; i<6; i++){
5211	s->dc_val[0][ s->block_index[i] ]= dc[i];
5212	memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5213	}
5214	}
5215	if(dir > 0 && dquant==dir){
5216	dquant= 0;
5217	dir= -dir;
5218	}else
5219	break;
5220	}
5221	}
5222	qp= best_s.qscale;
5223	s->current_picture.qscale_table[xy]= qp;
5224	}
5225	}
5226
5227	copy_context_after_encode(s, &best_s, -1);
5228
5229	pb_bits_count= put_bits_count(&s->pb);
5230	flush_put_bits(&s->pb);
5231	ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5232	s->pb= backup_s.pb;
5233
5234	if(s->data_partitioning){
5235	pb2_bits_count= put_bits_count(&s->pb2);
5236	flush_put_bits(&s->pb2);
5237	ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5238	s->pb2= backup_s.pb2;
5239
5240	tex_pb_bits_count= put_bits_count(&s->tex_pb);
5241	flush_put_bits(&s->tex_pb);
5242	ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5243	s->tex_pb= backup_s.tex_pb;
5244	}
5245	s->last_bits= put_bits_count(&s->pb);
5246
5247	if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5248	ff_h263_update_motion_val(s);
5249
5250	if(next_block==0){ //FIXME 16 vs linesize16
5251	s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5252	s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5253	s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5254	}
5255
5256	if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5257	MPV_decode_mb(s, s->block);
5258	} else {
5259	int motion_x, motion_y;
5260	s->mv_type=MV_TYPE_16X16;
5261	// only one MB-Type possible
5262
5263	switch(mb_type){
5264	case CANDIDATE_MB_TYPE_INTRA:
5265	s->mv_dir = 0;
5266	s->mb_intra= 1;
5267	motion_x= s->mv[0][0][0] = 0;
5268	motion_y= s->mv[0][0][1] = 0;
5269	break;
5270	case CANDIDATE_MB_TYPE_INTER:
5271	s->mv_dir = MV_DIR_FORWARD;
5272	s->mb_intra= 0;
5273	motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5274	motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5275	break;
5276	case CANDIDATE_MB_TYPE_INTER_I:
5277	s->mv_dir = MV_DIR_FORWARD;
5278	s->mv_type = MV_TYPE_FIELD;
5279	s->mb_intra= 0;
5280	for(i=0; i<2; i++){
5281	j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5282	s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5283	s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5284	}
5285	motion_x = motion_y = 0;
5286	break;
5287	case CANDIDATE_MB_TYPE_INTER4V:
5288	s->mv_dir = MV_DIR_FORWARD;
5289	s->mv_type = MV_TYPE_8X8;
5290	s->mb_intra= 0;
5291	for(i=0; i<4; i++){
5292	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5293	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5294	}
5295	motion_x= motion_y= 0;
5296	break;
5297	case CANDIDATE_MB_TYPE_DIRECT:
5298	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD \| MV_DIRECT;
5299	s->mb_intra= 0;
5300	motion_x=s->b_direct_mv_table[xy][0];
5301	motion_y=s->b_direct_mv_table[xy][1];
5302	ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5303	break;
5304	case CANDIDATE_MB_TYPE_BIDIR:
5305	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD;
5306	s->mb_intra= 0;
5307	motion_x=0;
5308	motion_y=0;
5309	s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5310	s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5311	s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5312	s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5313	break;
5314	case CANDIDATE_MB_TYPE_BACKWARD:
5315	s->mv_dir = MV_DIR_BACKWARD;
5316	s->mb_intra= 0;
5317	motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5318	motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5319	break;
5320	case CANDIDATE_MB_TYPE_FORWARD:
5321	s->mv_dir = MV_DIR_FORWARD;
5322	s->mb_intra= 0;
5323	motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5324	motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5325	// printf(" %d %d ", motion_x, motion_y);
5326	break;
5327	case CANDIDATE_MB_TYPE_FORWARD_I:
5328	s->mv_dir = MV_DIR_FORWARD;
5329	s->mv_type = MV_TYPE_FIELD;
5330	s->mb_intra= 0;
5331	for(i=0; i<2; i++){
5332	j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5333	s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5334	s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5335	}
5336	motion_x=motion_y=0;
5337	break;
5338	case CANDIDATE_MB_TYPE_BACKWARD_I:
5339	s->mv_dir = MV_DIR_BACKWARD;
5340	s->mv_type = MV_TYPE_FIELD;
5341	s->mb_intra= 0;
5342	for(i=0; i<2; i++){
5343	j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5344	s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5345	s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5346	}
5347	motion_x=motion_y=0;
5348	break;
5349	case CANDIDATE_MB_TYPE_BIDIR_I:
5350	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD;
5351	s->mv_type = MV_TYPE_FIELD;
5352	s->mb_intra= 0;
5353	for(dir=0; dir<2; dir++){
5354	for(i=0; i<2; i++){
5355	j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5356	s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5357	s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5358	}
5359	}
5360	motion_x=motion_y=0;
5361	break;
5362	default:
5363	motion_x=motion_y=0; //gcc warning fix
5364	av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5365	}
5366
5367	encode_mb(s, motion_x, motion_y);
5368
5369	// RAL: Update last macroblock type
5370	s->last_mv_dir = s->mv_dir;
5371
5372	if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5373	ff_h263_update_motion_val(s);
5374
5375	MPV_decode_mb(s, s->block);
5376	}
5377
5378	/* clean the MV table in IPS frames for direct mode in B frames */
5379	if(s->mb_intra /* && I,P,S_TYPE */){
5380	s->p_mv_table[xy][0]=0;
5381	s->p_mv_table[xy][1]=0;
5382	}
5383
5384	if(s->flags&CODEC_FLAG_PSNR){
5385	int w= 16;
5386	int h= 16;
5387
5388	if(s->mb_x16 + 16 > s->width ) w= s->width - s->mb_x16;
5389	if(s->mb_y16 + 16 > s->height) h= s->height- s->mb_y16;
5390
5391	s->current_picture.error[0] += sse(
5392	s, s->new_picture.data[0] + s->mb_x16 + s->mb_ys->linesize*16,
5393	s->dest[0], w, h, s->linesize);
5394	s->current_picture.error[1] += sse(
5395	s, s->new_picture.data[1] + s->mb_x8 + s->mb_ys->uvlinesize*8,
5396	s->dest[1], w>>1, h>>1, s->uvlinesize);
5397	s->current_picture.error[2] += sse(
5398	s, s->new_picture .data[2] + s->mb_x8 + s->mb_ys->uvlinesize*8,
5399	s->dest[2], w>>1, h>>1, s->uvlinesize);
5400	}
5401	if(s->loop_filter){
5402	if(s->out_format == FMT_H263)
5403	ff_h263_loop_filter(s);
5404	}
5405	//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5406	}
5407	}
5408
5409	//not beautiful here but we must write it before flushing so it has to be here
5410	if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5411	msmpeg4_encode_ext_header(s);
5412
5413	write_slice_end(s);
5414
5415	/* Send the last GOB if RTP */
5416	if (s->avctx->rtp_callback) {
5417	int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5418	pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5419	/* Call the RTP callback to send the last GOB */
5420	emms_c();
5421	s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5422	}
5423
5424	return 0;
5425	}
5426
5427	#define MERGE(field) dst->field += src->field; src->field=0
5428	static void merge_context_after_me(MpegEncContext dst, MpegEncContext src){
5429	MERGE(me.scene_change_score);
5430	MERGE(me.mc_mb_var_sum_temp);
5431	MERGE(me.mb_var_sum_temp);
5432	}
5433
5434	static void merge_context_after_encode(MpegEncContext dst, MpegEncContext src){
5435	int i;
5436
5437	MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5438	MERGE(dct_count[1]);
5439	MERGE(mv_bits);
5440	MERGE(i_tex_bits);
5441	MERGE(p_tex_bits);
5442	MERGE(i_count);
5443	MERGE(f_count);
5444	MERGE(b_count);
5445	MERGE(skip_count);
5446	MERGE(misc_bits);
5447	MERGE(error_count);
5448	MERGE(padding_bug_score);
5449	MERGE(current_picture.error[0]);
5450	MERGE(current_picture.error[1]);
5451	MERGE(current_picture.error[2]);
5452
5453	if(dst->avctx->noise_reduction){
5454	for(i=0; i<64; i++){
5455	MERGE(dct_error_sum[0][i]);
5456	MERGE(dct_error_sum[1][i]);
5457	}
5458	}
5459
5460	assert(put_bits_count(&src->pb) % 8 ==0);
5461	assert(put_bits_count(&dst->pb) % 8 ==0);
5462	ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5463	flush_put_bits(&dst->pb);
5464	}
5465
5466	static void estimate_qp(MpegEncContext *s, int dry_run){
5467	if (!s->fixed_qscale)
5468	s->current_picture_ptr->quality=
5469	s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5470
5471	if(s->adaptive_quant){
5472	switch(s->codec_id){
5473	case CODEC_ID_MPEG4:
5474	ff_clean_mpeg4_qscales(s);
5475	break;
5476	case CODEC_ID_H263:
5477	case CODEC_ID_H263P:
5478	case CODEC_ID_FLV1:
5479	ff_clean_h263_qscales(s);
5480	break;
5481	}
5482
5483	s->lambda= s->lambda_table[0];
5484	//FIXME broken
5485	}else
5486	s->lambda= s->current_picture.quality;
5487	//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5488	update_qscale(s);
5489	}
5490
5491	static void encode_picture(MpegEncContext *s, int picture_number)
5492	{
5493	int i;
5494	int bits;
5495
5496	s->picture_number = picture_number;
5497
5498	/* Reset the average MB variance */
5499	s->me.mb_var_sum_temp =
5500	s->me.mc_mb_var_sum_temp = 0;
5501
5502	/* we need to initialize some time vars before we can encode b-frames */
5503	// RAL: Condition added for MPEG1VIDEO
5504	if (s->codec_id == CODEC_ID_MPEG1VIDEO \|\| s->codec_id == CODEC_ID_MPEG2VIDEO \|\| (s->h263_pred && !s->h263_msmpeg4))
5505	ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5506
5507	s->me.scene_change_score=0;
5508
5509	// s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5510
5511	if(s->pict_type==I_TYPE){
5512	if(s->msmpeg4_version >= 3) s->no_rounding=1;
5513	else s->no_rounding=0;
5514	}else if(s->pict_type!=B_TYPE){
5515	if(s->flipflop_rounding \|\| s->codec_id == CODEC_ID_H263P \|\| s->codec_id == CODEC_ID_MPEG4)
5516	s->no_rounding ^= 1;
5517	}
5518
5519	if(s->flags & CODEC_FLAG_PASS2){
5520	estimate_qp(s, 1);
5521	ff_get_2pass_fcode(s);
5522	}else if(!(s->flags & CODEC_FLAG_QSCALE)){
5523	if(s->pict_type==B_TYPE)
5524	s->lambda= s->last_lambda_for[s->pict_type];
5525	else
5526	s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5527	update_qscale(s);
5528	}
5529
5530	s->mb_intra=0; //for the rate distortion & bit compare functions
5531	for(i=1; i<s->avctx->thread_count; i++){
5532	ff_update_duplicate_context(s->thread_context[i], s);
5533	}
5534
5535	ff_init_me(s);
5536
5537	/* Estimate motion for every MB */
5538	if(s->pict_type != I_TYPE){
5539	s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5540	s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5541	if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5542	if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) \|\| s->avctx->pre_me==2){
5543	s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5544	}
5545	}
5546
5547	s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5548	}else /* if(s->pict_type == I_TYPE) */{
5549	/* I-Frame */
5550	for(i=0; i<s->mb_stride*s->mb_height; i++)
5551	s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5552
5553	if(!s->fixed_qscale){
5554	/* finding spatial complexity for I-frame rate control */
5555	s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5556	}
5557	}
5558	for(i=1; i<s->avctx->thread_count; i++){
5559	merge_context_after_me(s, s->thread_context[i]);
5560	}
5561	s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5562	s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5563	emms_c();
5564
5565	if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5566	s->pict_type= I_TYPE;
5567	for(i=0; i<s->mb_stride*s->mb_height; i++)
5568	s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5569	//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5570	}
5571
5572	if(!s->umvplus){
5573	if(s->pict_type==P_TYPE \|\| s->pict_type==S_TYPE) {
5574	s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5575
5576	if(s->flags & CODEC_FLAG_INTERLACED_ME){
5577	int a,b;
5578	a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5579	b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5580	s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5581	}
5582
5583	ff_fix_long_p_mvs(s);
5584	ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5585	if(s->flags & CODEC_FLAG_INTERLACED_ME){
5586	int j;
5587	for(i=0; i<2; i++){
5588	for(j=0; j<2; j++)
5589	ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5590	s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5591	}
5592	}
5593	}
5594
5595	if(s->pict_type==B_TYPE){
5596	int a, b;
5597
5598	a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5599	b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5600	s->f_code = FFMAX(a, b);
5601
5602	a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5603	b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5604	s->b_code = FFMAX(a, b);
5605
5606	ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5607	ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5608	ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5609	ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5610	if(s->flags & CODEC_FLAG_INTERLACED_ME){
5611	int dir, j;
5612	for(dir=0; dir<2; dir++){
5613	for(i=0; i<2; i++){
5614	for(j=0; j<2; j++){
5615	int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I\|CANDIDATE_MB_TYPE_BIDIR_I)
5616	: (CANDIDATE_MB_TYPE_FORWARD_I \|CANDIDATE_MB_TYPE_BIDIR_I);
5617	ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5618	s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5619	}
5620	}
5621	}
5622	}
5623	}
5624	}
5625
5626	estimate_qp(s, 0);
5627
5628	if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5629	s->qscale= 3; //reduce clipping problems
5630
5631	if (s->out_format == FMT_MJPEG) {
5632	/* for mjpeg, we do include qscale in the matrix */
5633	s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5634	for(i=1;i<64;i++){
5635	int j= s->dsp.idct_permutation[i];
5636
5637	s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5638	}
5639	convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5640	s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5641	s->qscale= 8;
5642	}
5643
5644	//FIXME var duplication
5645	s->current_picture_ptr->key_frame=
5646	s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5647	s->current_picture_ptr->pict_type=
5648	s->current_picture.pict_type= s->pict_type;
5649
5650	if(s->current_picture.key_frame)
5651	s->picture_in_gop_number=0;
5652
5653	s->last_bits= put_bits_count(&s->pb);
5654	switch(s->out_format) {
5655	case FMT_MJPEG:
5656	mjpeg_picture_header(s);
5657	break;
5658	#ifdef CONFIG_H261_ENCODER
5659	case FMT_H261:
5660	ff_h261_encode_picture_header(s, picture_number);
5661	break;
5662	#endif
5663	case FMT_H263:
5664	if (s->codec_id == CODEC_ID_WMV2)
5665	ff_wmv2_encode_picture_header(s, picture_number);
5666	else if (s->h263_msmpeg4)
5667	msmpeg4_encode_picture_header(s, picture_number);
5668	else if (s->h263_pred)
5669	mpeg4_encode_picture_header(s, picture_number);
5670	#ifdef CONFIG_RV10_ENCODER
5671	else if (s->codec_id == CODEC_ID_RV10)
5672	rv10_encode_picture_header(s, picture_number);
5673	#endif
5674	#ifdef CONFIG_RV20_ENCODER
5675	else if (s->codec_id == CODEC_ID_RV20)
5676	rv20_encode_picture_header(s, picture_number);
5677	#endif
5678	else if (s->codec_id == CODEC_ID_FLV1)
5679	ff_flv_encode_picture_header(s, picture_number);
5680	else
5681	h263_encode_picture_header(s, picture_number);
5682	break;
5683	case FMT_MPEG1:
5684	mpeg1_encode_picture_header(s, picture_number);
5685	break;
5686	case FMT_H264:
5687	break;
5688	default:
5689	assert(0);
5690	}
5691	bits= put_bits_count(&s->pb);
5692	s->header_bits= bits - s->last_bits;
5693
5694	for(i=1; i<s->avctx->thread_count; i++){
5695	update_duplicate_context_after_me(s->thread_context[i], s);
5696	}
5697	s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5698	for(i=1; i<s->avctx->thread_count; i++){
5699	merge_context_after_encode(s, s->thread_context[i]);
5700	}
5701	emms_c();
5702	}
5703
5704	#endif //CONFIG_ENCODERS
5705
5706	static void denoise_dct_c(MpegEncContext s, DCTELEM block){
5707	const int intra= s->mb_intra;
5708	int i;
5709
5710	s->dct_count[intra]++;
5711
5712	for(i=0; i<64; i++){
5713	int level= block[i];
5714
5715	if(level){
5716	if(level>0){
5717	s->dct_error_sum[intra][i] += level;
5718	level -= s->dct_offset[intra][i];
5719	if(level<0) level=0;
5720	}else{
5721	s->dct_error_sum[intra][i] -= level;
5722	level += s->dct_offset[intra][i];
5723	if(level>0) level=0;
5724	}
5725	block[i]= level;
5726	}
5727	}
5728	}
5729
5730	#ifdef CONFIG_ENCODERS
5731
5732	static int dct_quantize_trellis_c(MpegEncContext *s,
5733	DCTELEM *block, int n,
5734	int qscale, int *overflow){
5735	const int *qmat;
5736	const uint8_t *scantable= s->intra_scantable.scantable;
5737	const uint8_t *perm_scantable= s->intra_scantable.permutated;
5738	int max=0;
5739	unsigned int threshold1, threshold2;
5740	int bias=0;
5741	int run_tab[65];
5742	int level_tab[65];
5743	int score_tab[65];
5744	int survivor[65];
5745	int survivor_count;
5746	int last_run=0;
5747	int last_level=0;
5748	int last_score= 0;
5749	int last_i;
5750	int coeff[2][64];
5751	int coeff_count[64];
5752	int qmul, qadd, start_i, last_non_zero, i, dc;
5753	const int esc_length= s->ac_esc_length;
5754	uint8_t * length;
5755	uint8_t * last_length;
5756	const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5757
5758	s->dsp.fdct (block);
5759
5760	if(s->dct_error_sum)
5761	s->denoise_dct(s, block);
5762	qmul= qscale*16;
5763	qadd= ((qscale-1)\|1)*8;
5764
5765	if (s->mb_intra) {
5766	int q;
5767	if (!s->h263_aic) {
5768	if (n < 4)
5769	q = s->y_dc_scale;
5770	else
5771	q = s->c_dc_scale;
5772	q = q << 3;
5773	} else{
5774	/* For AIC we skip quant/dequant of INTRADC */
5775	q = 1 << 3;
5776	qadd=0;
5777	}
5778
5779	/* note: block[0] is assumed to be positive */
5780	block[0] = (block[0] + (q >> 1)) / q;
5781	start_i = 1;
5782	last_non_zero = 0;
5783	qmat = s->q_intra_matrix[qscale];
5784	if(s->mpeg_quant \|\| s->out_format == FMT_MPEG1)
5785	bias= 1<<(QMAT_SHIFT-1);
5786	length = s->intra_ac_vlc_length;
5787	last_length= s->intra_ac_vlc_last_length;
5788	} else {
5789	start_i = 0;
5790	last_non_zero = -1;
5791	qmat = s->q_inter_matrix[qscale];
5792	length = s->inter_ac_vlc_length;
5793	last_length= s->inter_ac_vlc_last_length;
5794	}
5795	last_i= start_i;
5796
5797	threshold1= (1<<QMAT_SHIFT) - bias - 1;
5798	threshold2= (threshold1<<1);
5799
5800	for(i=63; i>=start_i; i--) {
5801	const int j = scantable[i];
5802	int level = block[j] * qmat[j];
5803
5804	if(((unsigned)(level+threshold1))>threshold2){
5805	last_non_zero = i;
5806	break;
5807	}
5808	}
5809
5810	for(i=start_i; i<=last_non_zero; i++) {
5811	const int j = scantable[i];
5812	int level = block[j] * qmat[j];
5813
5814	// if( bias+level >= (1<<(QMAT_SHIFT - 3))
5815	// \|\| bias-level >= (1<<(QMAT_SHIFT - 3))){
5816	if(((unsigned)(level+threshold1))>threshold2){
5817	if(level>0){
5818	level= (bias + level)>>QMAT_SHIFT;
5819	coeff[0][i]= level;
5820	coeff[1][i]= level-1;
5821	// coeff[2][k]= level-2;
5822	}else{
5823	level= (bias - level)>>QMAT_SHIFT;
5824	coeff[0][i]= -level;
5825	coeff[1][i]= -level+1;
5826	// coeff[2][k]= -level+2;
5827	}
5828	coeff_count[i]= FFMIN(level, 2);
5829	assert(coeff_count[i]);
5830	max \|=level;
5831	}else{
5832	coeff[0][i]= (level>>31)\|1;
5833	coeff_count[i]= 1;
5834	}
5835	}
5836
5837	*overflow= s->max_qcoeff < max; //overflow might have happened
5838
5839	if(last_non_zero < start_i){
5840	memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5841	return last_non_zero;
5842	}
5843
5844	score_tab[start_i]= 0;
5845	survivor[0]= start_i;
5846	survivor_count= 1;
5847
5848	for(i=start_i; i<=last_non_zero; i++){
5849	int level_index, j;
5850	const int dct_coeff= ABS(block[ scantable[i] ]);
5851	const int zero_distoration= dct_coeff*dct_coeff;
5852	int best_score=256256256*120;
5853	for(level_index=0; level_index < coeff_count[i]; level_index++){
5854	int distoration;
5855	int level= coeff[level_index][i];
5856	const int alevel= ABS(level);
5857	int unquant_coeff;
5858
5859	assert(level);
5860
5861	if(s->out_format == FMT_H263){
5862	unquant_coeff= alevel*qmul + qadd;
5863	}else{ //MPEG1
5864	j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5865	if(s->mb_intra){
5866	unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5867	unquant_coeff = (unquant_coeff - 1) \| 1;
5868	}else{
5869	unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5870	unquant_coeff = (unquant_coeff - 1) \| 1;
5871	}
5872	unquant_coeff<<= 3;
5873	}
5874
5875	distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5876	level+=64;
5877	if((level&(~127)) == 0){
5878	for(j=survivor_count-1; j>=0; j--){
5879	int run= i - survivor[j];
5880	int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5881	score += score_tab[i-run];
5882
5883	if(score < best_score){
5884	best_score= score;
5885	run_tab[i+1]= run;
5886	level_tab[i+1]= level-64;
5887	}
5888	}
5889
5890	if(s->out_format == FMT_H263){
5891	for(j=survivor_count-1; j>=0; j--){
5892	int run= i - survivor[j];
5893	int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5894	score += score_tab[i-run];
5895	if(score < last_score){
5896	last_score= score;
5897	last_run= run;
5898	last_level= level-64;
5899	last_i= i+1;
5900	}
5901	}
5902	}
5903	}else{
5904	distoration += esc_length*lambda;
5905	for(j=survivor_count-1; j>=0; j--){
5906	int run= i - survivor[j];
5907	int score= distoration + score_tab[i-run];
5908
5909	if(score < best_score){
5910	best_score= score;
5911	run_tab[i+1]= run;
5912	level_tab[i+1]= level-64;
5913	}
5914	}
5915
5916	if(s->out_format == FMT_H263){
5917	for(j=survivor_count-1; j>=0; j--){
5918	int run= i - survivor[j];
5919	int score= distoration + score_tab[i-run];
5920	if(score < last_score){
5921	last_score= score;
5922	last_run= run;
5923	last_level= level-64;
5924	last_i= i+1;
5925	}
5926	}
5927	}
5928	}
5929	}
5930
5931	score_tab[i+1]= best_score;
5932
5933	//Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5934	if(last_non_zero <= 27){
5935	for(; survivor_count; survivor_count--){
5936	if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5937	break;
5938	}
5939	}else{
5940	for(; survivor_count; survivor_count--){
5941	if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5942	break;
5943	}
5944	}
5945
5946	survivor[ survivor_count++ ]= i+1;
5947	}
5948
5949	if(s->out_format != FMT_H263){
5950	last_score= 256256256*120;
5951	for(i= survivor[0]; i<=last_non_zero + 1; i++){
5952	int score= score_tab[i];
5953	if(i) score += lambda*2; //FIXME exacter?
5954
5955	if(score < last_score){
5956	last_score= score;
5957	last_i= i;
5958	last_level= level_tab[i];
5959	last_run= run_tab[i];
5960	}
5961	}
5962	}
5963
5964	s->coded_score[n] = last_score;
5965
5966	dc= ABS(block[0]);
5967	last_non_zero= last_i - 1;
5968	memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5969
5970	if(last_non_zero < start_i)
5971	return last_non_zero;
5972
5973	if(last_non_zero == 0 && start_i == 0){
5974	int best_level= 0;
5975	int best_score= dc * dc;
5976
5977	for(i=0; i<coeff_count[0]; i++){
5978	int level= coeff[i][0];
5979	int alevel= ABS(level);
5980	int unquant_coeff, score, distortion;
5981
5982	if(s->out_format == FMT_H263){
5983	unquant_coeff= (alevel*qmul + qadd)>>3;
5984	}else{ //MPEG1
5985	unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5986	unquant_coeff = (unquant_coeff - 1) \| 1;
5987	}
5988	unquant_coeff = (unquant_coeff + 4) >> 3;
5989	unquant_coeff<<= 3 + 3;
5990
5991	distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5992	level+=64;
5993	if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
5994	else score= distortion + esc_length*lambda;
5995
5996	if(score < best_score){
5997	best_score= score;
5998	best_level= level - 64;
5999	}
6000	}
6001	block[0]= best_level;
6002	s->coded_score[n] = best_score - dc*dc;
6003	if(best_level == 0) return -1;
6004	else return last_non_zero;
6005	}
6006
6007	i= last_i;
6008	assert(last_level);
6009
6010	block[ perm_scantable[last_non_zero] ]= last_level;
6011	i -= last_run + 1;
6012
6013	for(; i>start_i; i -= run_tab[i] + 1){
6014	block[ perm_scantable[i-1] ]= level_tab[i];
6015	}
6016
6017	return last_non_zero;
6018	}
6019
6020	//#define REFINE_STATS 1
6021	static int16_t basis[64][64];
6022
6023	static void build_basis(uint8_t *perm){
6024	int i, j, x, y;
6025	emms_c();
6026	for(i=0; i<8; i++){
6027	for(j=0; j<8; j++){
6028	for(y=0; y<8; y++){
6029	for(x=0; x<8; x++){
6030	double s= 0.25*(1<<BASIS_SHIFT);
6031	int index= 8*i + j;
6032	int perm_index= perm[index];
6033	if(i==0) s*= sqrt(0.5);
6034	if(j==0) s*= sqrt(0.5);
6035	basis[perm_index][8x + y]= lrintf(s cos((M_PI/8.0)i(x+0.5)) * cos((M_PI/8.0)j(y+0.5)));
6036	}
6037	}
6038	}
6039	}
6040	}
6041
6042	static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
6043	DCTELEM block, int16_t weight, DCTELEM *orig,
6044	int n, int qscale){
6045	int16_t rem[64];
6046	DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6047	const int *qmat;
6048	const uint8_t *scantable= s->intra_scantable.scantable;
6049	const uint8_t *perm_scantable= s->intra_scantable.permutated;
6050	// unsigned int threshold1, threshold2;
6051	// int bias=0;
6052	int run_tab[65];
6053	int prev_run=0;
6054	int prev_level=0;
6055	int qmul, qadd, start_i, last_non_zero, i, dc;
6056	uint8_t * length;
6057	uint8_t * last_length;
6058	int lambda;
6059	int rle_index, run, q, sum;
6060	#ifdef REFINE_STATS
6061	static int count=0;
6062	static int after_last=0;
6063	static int to_zero=0;
6064	static int from_zero=0;
6065	static int raise=0;
6066	static int lower=0;
6067	static int messed_sign=0;
6068	#endif
6069
6070	if(basis[0][0] == 0)
6071	build_basis(s->dsp.idct_permutation);
6072
6073	qmul= qscale*2;
6074	qadd= (qscale-1)\|1;
6075	if (s->mb_intra) {
6076	if (!s->h263_aic) {
6077	if (n < 4)
6078	q = s->y_dc_scale;
6079	else
6080	q = s->c_dc_scale;
6081	} else{
6082	/* For AIC we skip quant/dequant of INTRADC */
6083	q = 1;
6084	qadd=0;
6085	}
6086	q <<= RECON_SHIFT-3;
6087	/* note: block[0] is assumed to be positive */
6088	dc= block[0]*q;
6089	// block[0] = (block[0] + (q >> 1)) / q;
6090	start_i = 1;
6091	qmat = s->q_intra_matrix[qscale];
6092	// if(s->mpeg_quant \|\| s->out_format == FMT_MPEG1)
6093	// bias= 1<<(QMAT_SHIFT-1);
6094	length = s->intra_ac_vlc_length;
6095	last_length= s->intra_ac_vlc_last_length;
6096	} else {
6097	dc= 0;
6098	start_i = 0;
6099	qmat = s->q_inter_matrix[qscale];
6100	length = s->inter_ac_vlc_length;
6101	last_length= s->inter_ac_vlc_last_length;
6102	}
6103	last_non_zero = s->block_last_index[n];
6104
6105	#ifdef REFINE_STATS
6106	{START_TIMER
6107	#endif
6108	dc += (1<<(RECON_SHIFT-1));
6109	for(i=0; i<64; i++){
6110	rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6111	}
6112	#ifdef REFINE_STATS
6113	STOP_TIMER("memset rem[]")}
6114	#endif
6115	sum=0;
6116	for(i=0; i<64; i++){
6117	int one= 36;
6118	int qns=4;
6119	int w;
6120
6121	w= ABS(weight[i]) + qns*one;
6122	w= 15 + (48qnsone + w/2)/w; // 16 .. 63
6123
6124	weight[i] = w;
6125	// w=weight[i] = (63*qns + (w/2)) / w;
6126
6127	assert(w>0);
6128	assert(w<(1<<6));
6129	sum += w*w;
6130	}
6131	lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6132	#ifdef REFINE_STATS
6133	{START_TIMER
6134	#endif
6135	run=0;
6136	rle_index=0;
6137	for(i=start_i; i<=last_non_zero; i++){
6138	int j= perm_scantable[i];
6139	const int level= block[j];
6140	int coeff;
6141
6142	if(level){
6143	if(level<0) coeff= qmul*level - qadd;
6144	else coeff= qmul*level + qadd;
6145	run_tab[rle_index++]=run;
6146	run=0;
6147
6148	s->dsp.add_8x8basis(rem, basis[j], coeff);
6149	}else{
6150	run++;
6151	}
6152	}
6153	#ifdef REFINE_STATS
6154	if(last_non_zero>0){
6155	STOP_TIMER("init rem[]")
6156	}
6157	}
6158
6159	{START_TIMER
6160	#endif
6161	for(;;){
6162	int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6163	int best_coeff=0;
6164	int best_change=0;
6165	int run2, best_unquant_change=0, analyze_gradient;
6166	#ifdef REFINE_STATS
6167	{START_TIMER
6168	#endif
6169	analyze_gradient = last_non_zero > 2 \|\| s->avctx->quantizer_noise_shaping >= 3;
6170
6171	if(analyze_gradient){
6172	#ifdef REFINE_STATS
6173	{START_TIMER
6174	#endif
6175	for(i=0; i<64; i++){
6176	int w= weight[i];
6177
6178	d1[i] = (rem[i]ww + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6179	}
6180	#ifdef REFINE_STATS
6181	STOP_TIMER("remww")}
6182	{START_TIMER
6183	#endif
6184	s->dsp.fdct(d1);
6185	#ifdef REFINE_STATS
6186	STOP_TIMER("dct")}
6187	#endif
6188	}
6189
6190	if(start_i){
6191	const int level= block[0];
6192	int change, old_coeff;
6193
6194	assert(s->mb_intra);
6195
6196	old_coeff= q*level;
6197
6198	for(change=-1; change<=1; change+=2){
6199	int new_level= level + change;
6200	int score, new_coeff;
6201
6202	new_coeff= q*new_level;
6203	if(new_coeff >= 2048 \|\| new_coeff < 0)
6204	continue;
6205
6206	score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6207	if(score<best_score){
6208	best_score= score;
6209	best_coeff= 0;
6210	best_change= change;
6211	best_unquant_change= new_coeff - old_coeff;
6212	}
6213	}
6214	}
6215
6216	run=0;
6217	rle_index=0;
6218	run2= run_tab[rle_index++];
6219	prev_level=0;
6220	prev_run=0;
6221
6222	for(i=start_i; i<64; i++){
6223	int j= perm_scantable[i];
6224	const int level= block[j];
6225	int change, old_coeff;
6226
6227	if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6228	break;
6229
6230	if(level){
6231	if(level<0) old_coeff= qmul*level - qadd;
6232	else old_coeff= qmul*level + qadd;
6233	run2= run_tab[rle_index++]; //FIXME ! maybe after last
6234	}else{
6235	old_coeff=0;
6236	run2--;
6237	assert(run2>=0 \|\| i >= last_non_zero );
6238	}
6239
6240	for(change=-1; change<=1; change+=2){
6241	int new_level= level + change;
6242	int score, new_coeff, unquant_change;
6243
6244	score=0;
6245	if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
6246	continue;
6247
6248	if(new_level){
6249	if(new_level<0) new_coeff= qmul*new_level - qadd;
6250	else new_coeff= qmul*new_level + qadd;
6251	if(new_coeff >= 2048 \|\| new_coeff <= -2048)
6252	continue;
6253	//FIXME check for overflow
6254
6255	if(level){
6256	if(level < 63 && level > -63){
6257	if(i < last_non_zero)
6258	score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6259	- length[UNI_AC_ENC_INDEX(run, level+64)];
6260	else
6261	score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6262	- last_length[UNI_AC_ENC_INDEX(run, level+64)];
6263	}
6264	}else{
6265	assert(ABS(new_level)==1);
6266
6267	if(analyze_gradient){
6268	int g= d1[ scantable[i] ];
6269	if(g && (g^new_level) >= 0)
6270	continue;
6271	}
6272
6273	if(i < last_non_zero){
6274	int next_i= i + run2 + 1;
6275	int next_level= block[ perm_scantable[next_i] ] + 64;
6276
6277	if(next_level&(~127))
6278	next_level= 0;
6279
6280	if(next_i < last_non_zero)
6281	score += length[UNI_AC_ENC_INDEX(run, 65)]
6282	+ length[UNI_AC_ENC_INDEX(run2, next_level)]
6283	- length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6284	else
6285	score += length[UNI_AC_ENC_INDEX(run, 65)]
6286	+ last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6287	- last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6288	}else{
6289	score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6290	if(prev_level){
6291	score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6292	- last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6293	}
6294	}
6295	}
6296	}else{
6297	new_coeff=0;
6298	assert(ABS(level)==1);
6299
6300	if(i < last_non_zero){
6301	int next_i= i + run2 + 1;
6302	int next_level= block[ perm_scantable[next_i] ] + 64;
6303
6304	if(next_level&(~127))
6305	next_level= 0;
6306
6307	if(next_i < last_non_zero)
6308	score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6309	- length[UNI_AC_ENC_INDEX(run2, next_level)]
6310	- length[UNI_AC_ENC_INDEX(run, 65)];
6311	else
6312	score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6313	- last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6314	- length[UNI_AC_ENC_INDEX(run, 65)];
6315	}else{
6316	score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6317	if(prev_level){
6318	score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6319	- length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6320	}
6321	}
6322	}
6323
6324	score *= lambda;
6325
6326	unquant_change= new_coeff - old_coeff;
6327	assert((score < 100lambda && score > -100lambda) \|\| lambda==0);
6328
6329	score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6330	if(score<best_score){
6331	best_score= score;
6332	best_coeff= i;
6333	best_change= change;
6334	best_unquant_change= unquant_change;
6335	}
6336	}
6337	if(level){
6338	prev_level= level + 64;
6339	if(prev_level&(~127))
6340	prev_level= 0;
6341	prev_run= run;
6342	run=0;
6343	}else{
6344	run++;
6345	}
6346	}
6347	#ifdef REFINE_STATS
6348	STOP_TIMER("iterative step")}
6349	#endif
6350
6351	if(best_change){
6352	int j= perm_scantable[ best_coeff ];
6353
6354	block[j] += best_change;
6355
6356	if(best_coeff > last_non_zero){
6357	last_non_zero= best_coeff;
6358	assert(block[j]);
6359	#ifdef REFINE_STATS
6360	after_last++;
6361	#endif
6362	}else{
6363	#ifdef REFINE_STATS
6364	if(block[j]){
6365	if(block[j] - best_change){
6366	if(ABS(block[j]) > ABS(block[j] - best_change)){
6367	raise++;
6368	}else{
6369	lower++;
6370	}
6371	}else{
6372	from_zero++;
6373	}
6374	}else{
6375	to_zero++;
6376	}
6377	#endif
6378	for(; last_non_zero>=start_i; last_non_zero--){
6379	if(block[perm_scantable[last_non_zero]])
6380	break;
6381	}
6382	}
6383	#ifdef REFINE_STATS
6384	count++;
6385	if(256256256*64 % count == 0){
6386	printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
6387	}
6388	#endif
6389	run=0;
6390	rle_index=0;
6391	for(i=start_i; i<=last_non_zero; i++){
6392	int j= perm_scantable[i];
6393	const int level= block[j];
6394
6395	if(level){
6396	run_tab[rle_index++]=run;
6397	run=0;
6398	}else{
6399	run++;
6400	}
6401	}
6402
6403	s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6404	}else{
6405	break;
6406	}
6407	}
6408	#ifdef REFINE_STATS
6409	if(last_non_zero>0){
6410	STOP_TIMER("iterative search")
6411	}
6412	}
6413	#endif
6414
6415	return last_non_zero;
6416	}
6417
6418	static int dct_quantize_c(MpegEncContext *s,
6419	DCTELEM *block, int n,
6420	int qscale, int *overflow)
6421	{
6422	int i, j, level, last_non_zero, q, start_i;
6423	const int *qmat;
6424	const uint8_t *scantable= s->intra_scantable.scantable;
6425	int bias;
6426	int max=0;
6427	unsigned int threshold1, threshold2;
6428
6429	s->dsp.fdct (block);
6430
6431	if(s->dct_error_sum)
6432	s->denoise_dct(s, block);
6433
6434	if (s->mb_intra) {
6435	if (!s->h263_aic) {
6436	if (n < 4)
6437	q = s->y_dc_scale;
6438	else
6439	q = s->c_dc_scale;
6440	q = q << 3;
6441	} else
6442	/* For AIC we skip quant/dequant of INTRADC */
6443	q = 1 << 3;
6444
6445	/* note: block[0] is assumed to be positive */
6446	block[0] = (block[0] + (q >> 1)) / q;
6447	start_i = 1;
6448	last_non_zero = 0;
6449	qmat = s->q_intra_matrix[qscale];
6450	bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6451	} else {
6452	start_i = 0;
6453	last_non_zero = -1;
6454	qmat = s->q_inter_matrix[qscale];
6455	bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6456	}
6457	threshold1= (1<<QMAT_SHIFT) - bias - 1;
6458	threshold2= (threshold1<<1);
6459	for(i=63;i>=start_i;i--) {
6460	j = scantable[i];
6461	level = block[j] * qmat[j];
6462
6463	if(((unsigned)(level+threshold1))>threshold2){
6464	last_non_zero = i;
6465	break;
6466	}else{
6467	block[j]=0;
6468	}
6469	}
6470	for(i=start_i; i<=last_non_zero; i++) {
6471	j = scantable[i];
6472	level = block[j] * qmat[j];
6473
6474	// if( bias+level >= (1<<QMAT_SHIFT)
6475	// \|\| bias-level >= (1<<QMAT_SHIFT)){
6476	if(((unsigned)(level+threshold1))>threshold2){
6477	if(level>0){
6478	level= (bias + level)>>QMAT_SHIFT;
6479	block[j]= level;
6480	}else{
6481	level= (bias - level)>>QMAT_SHIFT;
6482	block[j]= -level;
6483	}
6484	max \|=level;
6485	}else{
6486	block[j]=0;
6487	}
6488	}
6489	*overflow= s->max_qcoeff < max; //overflow might have happened
6490
6491	/* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6492	if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6493	ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6494
6495	return last_non_zero;
6496	}
6497
6498	#endif //CONFIG_ENCODERS
6499
6500	static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6501	DCTELEM *block, int n, int qscale)
6502	{
6503	int i, level, nCoeffs;
6504	const uint16_t *quant_matrix;
6505
6506	nCoeffs= s->block_last_index[n];
6507
6508	if (n < 4)
6509	block[0] = block[0] * s->y_dc_scale;
6510	else
6511	block[0] = block[0] * s->c_dc_scale;
6512	/* XXX: only mpeg1 */
6513	quant_matrix = s->intra_matrix;
6514	for(i=1;i<=nCoeffs;i++) {
6515	int j= s->intra_scantable.permutated[i];
6516	level = block[j];
6517	if (level) {
6518	if (level < 0) {
6519	level = -level;
6520	level = (int)(level * qscale * quant_matrix[j]) >> 3;
6521	level = (level - 1) \| 1;
6522	level = -level;
6523	} else {
6524	level = (int)(level * qscale * quant_matrix[j]) >> 3;
6525	level = (level - 1) \| 1;
6526	}
6527	block[j] = level;
6528	}
6529	}
6530	}
6531
6532	static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6533	DCTELEM *block, int n, int qscale)
6534	{
6535	int i, level, nCoeffs;
6536	const uint16_t *quant_matrix;
6537
6538	nCoeffs= s->block_last_index[n];
6539
6540	quant_matrix = s->inter_matrix;
6541	for(i=0; i<=nCoeffs; i++) {
6542	int j= s->intra_scantable.permutated[i];
6543	level = block[j];
6544	if (level) {
6545	if (level < 0) {
6546	level = -level;
6547	level = (((level << 1) + 1) * qscale *
6548	((int) (quant_matrix[j]))) >> 4;
6549	level = (level - 1) \| 1;
6550	level = -level;
6551	} else {
6552	level = (((level << 1) + 1) * qscale *
6553	((int) (quant_matrix[j]))) >> 4;
6554	level = (level - 1) \| 1;
6555	}
6556	block[j] = level;
6557	}
6558	}
6559	}
6560
6561	static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6562	DCTELEM *block, int n, int qscale)
6563	{
6564	int i, level, nCoeffs;
6565	const uint16_t *quant_matrix;
6566
6567	if(s->alternate_scan) nCoeffs= 63;
6568	else nCoeffs= s->block_last_index[n];
6569
6570	if (n < 4)
6571	block[0] = block[0] * s->y_dc_scale;
6572	else
6573	block[0] = block[0] * s->c_dc_scale;
6574	quant_matrix = s->intra_matrix;
6575	for(i=1;i<=nCoeffs;i++) {
6576	int j= s->intra_scantable.permutated[i];
6577	level = block[j];
6578	if (level) {
6579	if (level < 0) {
6580	level = -level;
6581	level = (int)(level * qscale * quant_matrix[j]) >> 3;
6582	level = -level;
6583	} else {
6584	level = (int)(level * qscale * quant_matrix[j]) >> 3;
6585	}
6586	block[j] = level;
6587	}
6588	}
6589	}
6590
6591	static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
6592	DCTELEM *block, int n, int qscale)
6593	{
6594	int i, level, nCoeffs;
6595	const uint16_t *quant_matrix;
6596	int sum=-1;
6597
6598	if(s->alternate_scan) nCoeffs= 63;
6599	else nCoeffs= s->block_last_index[n];
6600
6601	if (n < 4)
6602	block[0] = block[0] * s->y_dc_scale;
6603	else
6604	block[0] = block[0] * s->c_dc_scale;
6605	quant_matrix = s->intra_matrix;
6606	for(i=1;i<=nCoeffs;i++) {
6607	int j= s->intra_scantable.permutated[i];
6608	level = block[j];
6609	if (level) {
6610	if (level < 0) {
6611	level = -level;
6612	level = (int)(level * qscale * quant_matrix[j]) >> 3;
6613	level = -level;
6614	} else {
6615	level = (int)(level * qscale * quant_matrix[j]) >> 3;
6616	}
6617	block[j] = level;
6618	sum+=level;
6619	}
6620	}
6621	block[63]^=sum&1;
6622	}
6623
6624	static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6625	DCTELEM *block, int n, int qscale)
6626	{
6627	int i, level, nCoeffs;
6628	const uint16_t *quant_matrix;
6629	int sum=-1;
6630
6631	if(s->alternate_scan) nCoeffs= 63;
6632	else nCoeffs= s->block_last_index[n];
6633
6634	quant_matrix = s->inter_matrix;
6635	for(i=0; i<=nCoeffs; i++) {
6636	int j= s->intra_scantable.permutated[i];
6637	level = block[j];
6638	if (level) {
6639	if (level < 0) {
6640	level = -level;
6641	level = (((level << 1) + 1) * qscale *
6642	((int) (quant_matrix[j]))) >> 4;
6643	level = -level;
6644	} else {
6645	level = (((level << 1) + 1) * qscale *
6646	((int) (quant_matrix[j]))) >> 4;
6647	}
6648	block[j] = level;
6649	sum+=level;
6650	}
6651	}
6652	block[63]^=sum&1;
6653	}
6654
6655	static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6656	DCTELEM *block, int n, int qscale)
6657	{
6658	int i, level, qmul, qadd;
6659	int nCoeffs;
6660
6661	assert(s->block_last_index[n]>=0);
6662
6663	qmul = qscale << 1;
6664
6665	if (!s->h263_aic) {
6666	if (n < 4)
6667	block[0] = block[0] * s->y_dc_scale;
6668	else
6669	block[0] = block[0] * s->c_dc_scale;
6670	qadd = (qscale - 1) \| 1;
6671	}else{
6672	qadd = 0;
6673	}
6674	if(s->ac_pred)
6675	nCoeffs=63;
6676	else
6677	nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6678
6679	for(i=1; i<=nCoeffs; i++) {
6680	level = block[i];
6681	if (level) {
6682	if (level < 0) {
6683	level = level * qmul - qadd;
6684	} else {
6685	level = level * qmul + qadd;
6686	}
6687	block[i] = level;
6688	}
6689	}
6690	}
6691
6692	static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6693	DCTELEM *block, int n, int qscale)
6694	{
6695	int i, level, qmul, qadd;
6696	int nCoeffs;
6697
6698	assert(s->block_last_index[n]>=0);
6699
6700	qadd = (qscale - 1) \| 1;
6701	qmul = qscale << 1;
6702
6703	nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6704
6705	for(i=0; i<=nCoeffs; i++) {
6706	level = block[i];
6707	if (level) {
6708	if (level < 0) {
6709	level = level * qmul - qadd;
6710	} else {
6711	level = level * qmul + qadd;
6712	}
6713	block[i] = level;
6714	}
6715	}
6716	}
6717
6718	#ifdef CONFIG_ENCODERS
6719	AVCodec h263_encoder = {
6720	"h263",
6721	CODEC_TYPE_VIDEO,
6722	CODEC_ID_H263,
6723	sizeof(MpegEncContext),
6724	MPV_encode_init,
6725	MPV_encode_picture,
6726	MPV_encode_end,
6727	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6728	};
6729
6730	AVCodec h263p_encoder = {
6731	"h263p",
6732	CODEC_TYPE_VIDEO,
6733	CODEC_ID_H263P,
6734	sizeof(MpegEncContext),
6735	MPV_encode_init,
6736	MPV_encode_picture,
6737	MPV_encode_end,
6738	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6739	};
6740
6741	AVCodec flv_encoder = {
6742	"flv",
6743	CODEC_TYPE_VIDEO,
6744	CODEC_ID_FLV1,
6745	sizeof(MpegEncContext),
6746	MPV_encode_init,
6747	MPV_encode_picture,
6748	MPV_encode_end,
6749	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6750	};
6751
6752	AVCodec rv10_encoder = {
6753	"rv10",
6754	CODEC_TYPE_VIDEO,
6755	CODEC_ID_RV10,
6756	sizeof(MpegEncContext),
6757	MPV_encode_init,
6758	MPV_encode_picture,
6759	MPV_encode_end,
6760	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6761	};
6762
6763	AVCodec rv20_encoder = {
6764	"rv20",
6765	CODEC_TYPE_VIDEO,
6766	CODEC_ID_RV20,
6767	sizeof(MpegEncContext),
6768	MPV_encode_init,
6769	MPV_encode_picture,
6770	MPV_encode_end,
6771	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6772	};
6773
6774	AVCodec mpeg4_encoder = {
6775	"mpeg4",
6776	CODEC_TYPE_VIDEO,
6777	CODEC_ID_MPEG4,
6778	sizeof(MpegEncContext),
6779	MPV_encode_init,
6780	MPV_encode_picture,
6781	MPV_encode_end,
6782	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6783	.capabilities= CODEC_CAP_DELAY,
6784	};
6785
6786	AVCodec msmpeg4v1_encoder = {
6787	"msmpeg4v1",
6788	CODEC_TYPE_VIDEO,
6789	CODEC_ID_MSMPEG4V1,
6790	sizeof(MpegEncContext),
6791	MPV_encode_init,
6792	MPV_encode_picture,
6793	MPV_encode_end,
6794	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6795	};
6796
6797	AVCodec msmpeg4v2_encoder = {
6798	"msmpeg4v2",
6799	CODEC_TYPE_VIDEO,
6800	CODEC_ID_MSMPEG4V2,
6801	sizeof(MpegEncContext),
6802	MPV_encode_init,
6803	MPV_encode_picture,
6804	MPV_encode_end,
6805	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6806	};
6807
6808	AVCodec msmpeg4v3_encoder = {
6809	"msmpeg4",
6810	CODEC_TYPE_VIDEO,
6811	CODEC_ID_MSMPEG4V3,
6812	sizeof(MpegEncContext),
6813	MPV_encode_init,
6814	MPV_encode_picture,
6815	MPV_encode_end,
6816	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6817	};
6818
6819	AVCodec wmv1_encoder = {
6820	"wmv1",
6821	CODEC_TYPE_VIDEO,
6822	CODEC_ID_WMV1,
6823	sizeof(MpegEncContext),
6824	MPV_encode_init,
6825	MPV_encode_picture,
6826	MPV_encode_end,
6827	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6828	};
6829
6830	AVCodec mjpeg_encoder = {
6831	"mjpeg",
6832	CODEC_TYPE_VIDEO,
6833	CODEC_ID_MJPEG,
6834	sizeof(MpegEncContext),
6835	MPV_encode_init,
6836	MPV_encode_picture,
6837	MPV_encode_end,
6838	.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, -1},
6839	};
6840
6841	#endif //CONFIG_ENCODERS

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/ffmpeg-20060710/libavcodec/mpegvideo.c@ 7692

Download in other formats: