path: root/libavcodec/mpegvideo_enc.c (plain)
blob: db241c82f0982bc2ed4f8e7f3534505ffef041ee

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	* 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7	*
8	* This file is part of FFmpeg.
9	*
10	* FFmpeg is free software; you can redistribute it and/or
11	* modify it under the terms of the GNU Lesser General Public
12	* License as published by the Free Software Foundation; either
13	* version 2.1 of the License, or (at your option) any later version.
14	*
15	* FFmpeg is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18	* Lesser General Public License for more details.
19	*
20	* You should have received a copy of the GNU Lesser General Public
21	* License along with FFmpeg; if not, write to the Free Software
22	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23	*/
24
25	/*
26	* non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
27	*/
28
29	/**
30	* @file
31	* The simplest mpeg encoder (well, it was the simplest!).
32	*/
33
34	#include <stdint.h>
35
36	#include "libavutil/internal.h"
37	#include "libavutil/intmath.h"
38	#include "libavutil/mathematics.h"
39	#include "libavutil/pixdesc.h"
40	#include "libavutil/opt.h"
41	#include "libavutil/timer.h"
42	#include "avcodec.h"
43	#include "dct.h"
44	#include "idctdsp.h"
45	#include "mpeg12.h"
46	#include "mpegvideo.h"
47	#include "mpegvideodata.h"
48	#include "h261.h"
49	#include "h263.h"
50	#include "h263data.h"
51	#include "mjpegenc_common.h"
52	#include "mathops.h"
53	#include "mpegutils.h"
54	#include "mjpegenc.h"
55	#include "msmpeg4.h"
56	#include "pixblockdsp.h"
57	#include "qpeldsp.h"
58	#include "faandct.h"
59	#include "thread.h"
60	#include "aandcttab.h"
61	#include "flv.h"
62	#include "mpeg4video.h"
63	#include "internal.h"
64	#include "bytestream.h"
65	#include "wmv2.h"
66	#include "rv10.h"
67	#include "libxvid.h"
68	#include <limits.h>
69	#include "sp5x.h"
70
71	#define QUANT_BIAS_SHIFT 8
72
73	#define QMAT_SHIFT_MMX 16
74	#define QMAT_SHIFT 21
75
76	static int encode_picture(MpegEncContext *s, int picture_number);
77	static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
78	static int sse_mb(MpegEncContext *s);
79	static void denoise_dct_c(MpegEncContext *s, int16_t *block);
80	static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
81
82	static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
83	static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
84
85	const AVOption ff_mpv_generic_options[] = {
86	FF_MPV_COMMON_OPTS
87	{ NULL },
88	};
89
90	void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
91	uint16_t (*qmat16)[2][64],
92	const uint16_t *quant_matrix,
93	int bias, int qmin, int qmax, int intra)
94	{
95	FDCTDSPContext *fdsp = &s->fdsp;
96	int qscale;
97	int shift = 0;
98
99	for (qscale = qmin; qscale <= qmax; qscale++) {
100	int i;
101	int qscale2;
102
103	if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
104	else qscale2 = qscale << 1;
105
106	if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
107	#if CONFIG_FAANDCT
108	fdsp->fdct == ff_faandct ||
109	#endif /* CONFIG_FAANDCT */
110	fdsp->fdct == ff_jpeg_fdct_islow_10) {
111	for (i = 0; i < 64; i++) {
112	const int j = s->idsp.idct_permutation[i];
113	int64_t den = (int64_t) qscale2 * quant_matrix[j];
114	/* 16 <= qscale * quant_matrix[i] <= 7905
115	* Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
116	* 19952 <= x <= 249205026
117	* (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
118	* 3444240 >= (1 << 36) / (x) >= 275 */
119
120	qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
121	}
122	} else if (fdsp->fdct == ff_fdct_ifast) {
123	for (i = 0; i < 64; i++) {
124	const int j = s->idsp.idct_permutation[i];
125	int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
126	/* 16 <= qscale * quant_matrix[i] <= 7905
127	* Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
128	* 19952 <= x <= 249205026
129	* (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
130	* 3444240 >= (1 << 36) / (x) >= 275 */
131
132	qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
133	}
134	} else {
135	for (i = 0; i < 64; i++) {
136	const int j = s->idsp.idct_permutation[i];
137	int64_t den = (int64_t) qscale2 * quant_matrix[j];
138	/* We can safely suppose that 16 <= quant_matrix[i] <= 255
139	* Assume x = qscale * quant_matrix[i]
140	* So 16 <= x <= 7905
141	* so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
142	* so 32768 >= (1 << 19) / (x) >= 67 */
143	qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
144	//qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
145	// (qscale * quant_matrix[i]);
146	qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
147
148	if (qmat16[qscale][0][i] == 0 ||
149	qmat16[qscale][0][i] == 128 * 256)
150	qmat16[qscale][0][i] = 128 * 256 - 1;
151	qmat16[qscale][1][i] =
152	ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
153	qmat16[qscale][0][i]);
154	}
155	}
156
157	for (i = intra; i < 64; i++) {
158	int64_t max = 8191;
159	if (fdsp->fdct == ff_fdct_ifast) {
160	max = (8191LL * ff_aanscales[i]) >> 14;
161	}
162	while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
163	shift++;
164	}
165	}
166	}
167	if (shift) {
168	av_log(NULL, AV_LOG_INFO,
169	"Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
170	QMAT_SHIFT - shift);
171	}
172	}
173
174	static inline void update_qscale(MpegEncContext *s)
175	{
176	if (s->q_scale_type == 1 && 0) {
177	int i;
178	int bestdiff=INT_MAX;
179	int best = 1;
180
181	for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
182	int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
183	if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
184	(ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
185	continue;
186	if (diff < bestdiff) {
187	bestdiff = diff;
188	best = i;
189	}
190	}
191	s->qscale = best;
192	} else {
193	s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
194	(FF_LAMBDA_SHIFT + 7);
195	s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
196	}
197
198	s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
199	FF_LAMBDA_SHIFT;
200	}
201
202	void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
203	{
204	int i;
205
206	if (matrix) {
207	put_bits(pb, 1, 1);
208	for (i = 0; i < 64; i++) {
209	put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
210	}
211	} else
212	put_bits(pb, 1, 0);
213	}
214
215	/**
216	* init s->current_picture.qscale_table from s->lambda_table
217	*/
218	void ff_init_qscale_tab(MpegEncContext *s)
219	{
220	int8_t * const qscale_table = s->current_picture.qscale_table;
221	int i;
222
223	for (i = 0; i < s->mb_num; i++) {
224	unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
225	int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
226	qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
227	s->avctx->qmax);
228	}
229	}
230
231	static void update_duplicate_context_after_me(MpegEncContext *dst,
232	MpegEncContext *src)
233	{
234	#define COPY(a) dst->a= src->a
235	COPY(pict_type);
236	COPY(current_picture);
237	COPY(f_code);
238	COPY(b_code);
239	COPY(qscale);
240	COPY(lambda);
241	COPY(lambda2);
242	COPY(picture_in_gop_number);
243	COPY(gop_picture_number);
244	COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
245	COPY(progressive_frame); // FIXME don't set in encode_header
246	COPY(partitioned_frame); // FIXME don't set in encode_header
247	#undef COPY
248	}
249
250	/**
251	* Set the given MpegEncContext to defaults for encoding.
252	* the changed fields will not depend upon the prior state of the MpegEncContext.
253	*/
254	static void mpv_encode_defaults(MpegEncContext *s)
255	{
256	int i;
257	ff_mpv_common_defaults(s);
258
259	for (i = -16; i < 16; i++) {
260	default_fcode_tab[i + MAX_MV] = 1;
261	}
262	s->me.mv_penalty = default_mv_penalty;
263	s->fcode_tab = default_fcode_tab;
264
265	s->input_picture_number = 0;
266	s->picture_in_gop_number = 0;
267	}
268
269	av_cold int ff_dct_encode_init(MpegEncContext *s)
270	{
271	if (ARCH_X86)
272	ff_dct_encode_init_x86(s);
273
274	if (CONFIG_H263_ENCODER)
275	ff_h263dsp_init(&s->h263dsp);
276	if (!s->dct_quantize)
277	s->dct_quantize = ff_dct_quantize_c;
278	if (!s->denoise_dct)
279	s->denoise_dct = denoise_dct_c;
280	s->fast_dct_quantize = s->dct_quantize;
281	if (s->avctx->trellis)
282	s->dct_quantize = dct_quantize_trellis_c;
283
284	return 0;
285	}
286
287	/* init video encoder */
288	av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
289	{
290	MpegEncContext *s = avctx->priv_data;
291	AVCPBProperties *cpb_props;
292	int i, ret, format_supported;
293
294	mpv_encode_defaults(s);
295
296	switch (avctx->codec_id) {
297	case AV_CODEC_ID_MPEG2VIDEO:
298	if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
299	avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
300	av_log(avctx, AV_LOG_ERROR,
301	"only YUV420 and YUV422 are supported\n");
302	return -1;
303	}
304	break;
305	case AV_CODEC_ID_MJPEG:
306	case AV_CODEC_ID_AMV:
307	format_supported = 0;
308	/* JPEG color space */
309	if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
310	avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
311	avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
312	(avctx->color_range == AVCOL_RANGE_JPEG &&
313	(avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
314	avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
315	avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
316	format_supported = 1;
317	/* MPEG color space */
318	else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
319	(avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
320	avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
321	avctx->pix_fmt == AV_PIX_FMT_YUV444P))
322	format_supported = 1;
323
324	if (!format_supported) {
325	av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
326	return -1;
327	}
328	break;
329	default:
330	if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
331	av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
332	return -1;
333	}
334	}
335
336	switch (avctx->pix_fmt) {
337	case AV_PIX_FMT_YUVJ444P:
338	case AV_PIX_FMT_YUV444P:
339	s->chroma_format = CHROMA_444;
340	break;
341	case AV_PIX_FMT_YUVJ422P:
342	case AV_PIX_FMT_YUV422P:
343	s->chroma_format = CHROMA_422;
344	break;
345	case AV_PIX_FMT_YUVJ420P:
346	case AV_PIX_FMT_YUV420P:
347	default:
348	s->chroma_format = CHROMA_420;
349	break;
350	}
351
352	avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
353
354	#if FF_API_PRIVATE_OPT
355	FF_DISABLE_DEPRECATION_WARNINGS
356	if (avctx->rtp_payload_size)
357	s->rtp_payload_size = avctx->rtp_payload_size;
358	if (avctx->me_penalty_compensation)
359	s->me_penalty_compensation = avctx->me_penalty_compensation;
360	if (avctx->pre_me)
361	s->me_pre = avctx->pre_me;
362	FF_ENABLE_DEPRECATION_WARNINGS
363	#endif
364
365	s->bit_rate = avctx->bit_rate;
366	s->width = avctx->width;
367	s->height = avctx->height;
368	if (avctx->gop_size > 600 &&
369	avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
370	av_log(avctx, AV_LOG_WARNING,
371	"keyframe interval too large!, reducing it from %d to %d\n",
372	avctx->gop_size, 600);
373	avctx->gop_size = 600;
374	}
375	s->gop_size = avctx->gop_size;
376	s->avctx = avctx;
377	if (avctx->max_b_frames > MAX_B_FRAMES) {
378	av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
379	"is %d.\n", MAX_B_FRAMES);
380	avctx->max_b_frames = MAX_B_FRAMES;
381	}
382	s->max_b_frames = avctx->max_b_frames;
383	s->codec_id = avctx->codec->id;
384	s->strict_std_compliance = avctx->strict_std_compliance;
385	s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
386	s->rtp_mode = !!s->rtp_payload_size;
387	s->intra_dc_precision = avctx->intra_dc_precision;
388
389	// workaround some differences between how applications specify dc precision
390	if (s->intra_dc_precision < 0) {
391	s->intra_dc_precision += 8;
392	} else if (s->intra_dc_precision >= 8)
393	s->intra_dc_precision -= 8;
394
395	if (s->intra_dc_precision < 0) {
396	av_log(avctx, AV_LOG_ERROR,
397	"intra dc precision must be positive, note some applications use"
398	" 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
399	return AVERROR(EINVAL);
400	}
401
402	if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
403	s->huffman = 0;
404
405	if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
406	av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
407	return AVERROR(EINVAL);
408	}
409	s->user_specified_pts = AV_NOPTS_VALUE;
410
411	if (s->gop_size <= 1) {
412	s->intra_only = 1;
413	s->gop_size = 12;
414	} else {
415	s->intra_only = 0;
416	}
417
418	#if FF_API_MOTION_EST
419	FF_DISABLE_DEPRECATION_WARNINGS
420	s->me_method = avctx->me_method;
421	FF_ENABLE_DEPRECATION_WARNINGS
422	#endif
423
424	/* Fixed QSCALE */
425	s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
426
427	#if FF_API_MPV_OPT
428	FF_DISABLE_DEPRECATION_WARNINGS
429	if (avctx->border_masking != 0.0)
430	s->border_masking = avctx->border_masking;
431	FF_ENABLE_DEPRECATION_WARNINGS
432	#endif
433
434	s->adaptive_quant = (s->avctx->lumi_masking ||
435	s->avctx->dark_masking ||
436	s->avctx->temporal_cplx_masking ||
437	s->avctx->spatial_cplx_masking ||
438	s->avctx->p_masking ||
439	s->border_masking ||
440	(s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
441	!s->fixed_qscale;
442
443	s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
444
445	if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
446	switch(avctx->codec_id) {
447	case AV_CODEC_ID_MPEG1VIDEO:
448	case AV_CODEC_ID_MPEG2VIDEO:
449	avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
450	break;
451	case AV_CODEC_ID_MPEG4:
452	case AV_CODEC_ID_MSMPEG4V1:
453	case AV_CODEC_ID_MSMPEG4V2:
454	case AV_CODEC_ID_MSMPEG4V3:
455	if (avctx->rc_max_rate >= 15000000) {
456	avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
457	} else if(avctx->rc_max_rate >= 2000000) {
458	avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000LL) * (320- 80) / (15000000 - 2000000);
459	} else if(avctx->rc_max_rate >= 384000) {
460	avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000LL) * ( 80- 40) / ( 2000000 - 384000);
461	} else
462	avctx->rc_buffer_size = 40;
463	avctx->rc_buffer_size *= 16384;
464	break;
465	}
466	if (avctx->rc_buffer_size) {
467	av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
468	}
469	}
470
471	if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
472	av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
473	return -1;
474	}
475
476	if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
477	av_log(avctx, AV_LOG_INFO,
478	"Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
479	}
480
481	if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
482	av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
483	return -1;
484	}
485
486	if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
487	av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
488	return -1;
489	}
490
491	if (avctx->rc_max_rate &&
492	avctx->rc_max_rate == avctx->bit_rate &&
493	avctx->rc_max_rate != avctx->rc_min_rate) {
494	av_log(avctx, AV_LOG_INFO,
495	"impossible bitrate constraints, this will fail\n");
496	}
497
498	if (avctx->rc_buffer_size &&
499	avctx->bit_rate * (int64_t)avctx->time_base.num >
500	avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
501	av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
502	return -1;
503	}
504
505	if (!s->fixed_qscale &&
506	avctx->bit_rate * av_q2d(avctx->time_base) >
507	avctx->bit_rate_tolerance) {
508	av_log(avctx, AV_LOG_WARNING,
509	"bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, (int64_t)avctx->bit_rate);
510	avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
511	}
512
513	if (s->avctx->rc_max_rate &&
514	s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
515	(s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
516	s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
517	90000LL * (avctx->rc_buffer_size - 1) >
518	s->avctx->rc_max_rate * 0xFFFFLL) {
519	av_log(avctx, AV_LOG_INFO,
520	"Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
521	"specified vbv buffer is too large for the given bitrate!\n");
522	}
523
524	if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
525	s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
526	s->codec_id != AV_CODEC_ID_FLV1) {
527	av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
528	return -1;
529	}
530
531	if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
532	av_log(avctx, AV_LOG_ERROR,
533	"OBMC is only supported with simple mb decision\n");
534	return -1;
535	}
536
537	if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
538	av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
539	return -1;
540	}
541
542	if (s->max_b_frames &&
543	s->codec_id != AV_CODEC_ID_MPEG4 &&
544	s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
545	s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
546	av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
547	return -1;
548	}
549	if (s->max_b_frames < 0) {
550	av_log(avctx, AV_LOG_ERROR,
551	"max b frames must be 0 or positive for mpegvideo based encoders\n");
552	return -1;
553	}
554
555	if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
556	s->codec_id == AV_CODEC_ID_H263 ||
557	s->codec_id == AV_CODEC_ID_H263P) &&
558	(avctx->sample_aspect_ratio.num > 255 ||
559	avctx->sample_aspect_ratio.den > 255)) {
560	av_log(avctx, AV_LOG_WARNING,
561	"Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
562	avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
563	av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
564	avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
565	}
566
567	if ((s->codec_id == AV_CODEC_ID_H263 ||
568	s->codec_id == AV_CODEC_ID_H263P) &&
569	(avctx->width > 2048 ||
570	avctx->height > 1152 )) {
571	av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
572	return -1;
573	}
574	if ((s->codec_id == AV_CODEC_ID_H263 ||
575	s->codec_id == AV_CODEC_ID_H263P) &&
576	((avctx->width &3) ||
577	(avctx->height&3) )) {
578	av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
579	return -1;
580	}
581
582	if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
583	(avctx->width > 4095 ||
584	avctx->height > 4095 )) {
585	av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
586	return -1;
587	}
588
589	if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
590	(avctx->width > 16383 ||
591	avctx->height > 16383 )) {
592	av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
593	return -1;
594	}
595
596	if (s->codec_id == AV_CODEC_ID_RV10 &&
597	(avctx->width &15 ||
598	avctx->height&15 )) {
599	av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
600	return AVERROR(EINVAL);
601	}
602
603	if (s->codec_id == AV_CODEC_ID_RV20 &&
604	(avctx->width &3 ||
605	avctx->height&3 )) {
606	av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
607	return AVERROR(EINVAL);
608	}
609
610	if ((s->codec_id == AV_CODEC_ID_WMV1 ||
611	s->codec_id == AV_CODEC_ID_WMV2) &&
612	avctx->width & 1) {
613	av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
614	return -1;
615	}
616
617	if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
618	s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
619	av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
620	return -1;
621	}
622
623	#if FF_API_PRIVATE_OPT
624	FF_DISABLE_DEPRECATION_WARNINGS
625	if (avctx->mpeg_quant)
626	s->mpeg_quant = avctx->mpeg_quant;
627	FF_ENABLE_DEPRECATION_WARNINGS
628	#endif
629
630	// FIXME mpeg2 uses that too
631	if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
632	&& s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
633	av_log(avctx, AV_LOG_ERROR,
634	"mpeg2 style quantization not supported by codec\n");
635	return -1;
636	}
637
638	if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
639	av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
640	return -1;
641	}
642
643	if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
644	s->avctx->mb_decision != FF_MB_DECISION_RD) {
645	av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
646	return -1;
647	}
648
649	if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
650	(s->codec_id == AV_CODEC_ID_AMV ||
651	s->codec_id == AV_CODEC_ID_MJPEG)) {
652	// Used to produce garbage with MJPEG.
653	av_log(avctx, AV_LOG_ERROR,
654	"QP RD is no longer compatible with MJPEG or AMV\n");
655	return -1;
656	}
657
658	#if FF_API_PRIVATE_OPT
659	FF_DISABLE_DEPRECATION_WARNINGS
660	if (avctx->scenechange_threshold)
661	s->scenechange_threshold = avctx->scenechange_threshold;
662	FF_ENABLE_DEPRECATION_WARNINGS
663	#endif
664
665	if (s->scenechange_threshold < 1000000000 &&
666	(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
667	av_log(avctx, AV_LOG_ERROR,
668	"closed gop with scene change detection are not supported yet, "
669	"set threshold to 1000000000\n");
670	return -1;
671	}
672
673	if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
674	if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
675	av_log(avctx, AV_LOG_ERROR,
676	"low delay forcing is only available for mpeg2\n");
677	return -1;
678	}
679	if (s->max_b_frames != 0) {
680	av_log(avctx, AV_LOG_ERROR,
681	"B-frames cannot be used with low delay\n");
682	return -1;
683	}
684	}
685
686	if (s->q_scale_type == 1) {
687	if (avctx->qmax > 28) {
688	av_log(avctx, AV_LOG_ERROR,
689	"non linear quant only supports qmax <= 28 currently\n");
690	return -1;
691	}
692	}
693
694	if (avctx->slices > 1 &&
695	(avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
696	av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
697	return AVERROR(EINVAL);
698	}
699
700	if (s->avctx->thread_count > 1 &&
701	s->codec_id != AV_CODEC_ID_MPEG4 &&
702	s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
703	s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
704	s->codec_id != AV_CODEC_ID_MJPEG &&
705	(s->codec_id != AV_CODEC_ID_H263P)) {
706	av_log(avctx, AV_LOG_ERROR,
707	"multi threaded encoding not supported by codec\n");
708	return -1;
709	}
710
711	if (s->avctx->thread_count < 1) {
712	av_log(avctx, AV_LOG_ERROR,
713	"automatic thread number detection not supported by codec, "
714	"patch welcome\n");
715	return -1;
716	}
717
718	if (!avctx->time_base.den || !avctx->time_base.num) {
719	av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
720	return -1;
721	}
722
723	#if FF_API_PRIVATE_OPT
724	FF_DISABLE_DEPRECATION_WARNINGS
725	if (avctx->b_frame_strategy)
726	s->b_frame_strategy = avctx->b_frame_strategy;
727	if (avctx->b_sensitivity != 40)
728	s->b_sensitivity = avctx->b_sensitivity;
729	FF_ENABLE_DEPRECATION_WARNINGS
730	#endif
731
732	if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
733	av_log(avctx, AV_LOG_INFO,
734	"notice: b_frame_strategy only affects the first pass\n");
735	s->b_frame_strategy = 0;
736	}
737
738	i = av_gcd(avctx->time_base.den, avctx->time_base.num);
739	if (i > 1) {
740	av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
741	avctx->time_base.den /= i;
742	avctx->time_base.num /= i;
743	//return -1;
744	}
745
746	if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
747	// (a + x * 3 / 8) / x
748	s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
749	s->inter_quant_bias = 0;
750	} else {
751	s->intra_quant_bias = 0;
752	// (a - x / 4) / x
753	s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
754	}
755
756	if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
757	av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
758	return AVERROR(EINVAL);
759	}
760
761	#if FF_API_QUANT_BIAS
762	FF_DISABLE_DEPRECATION_WARNINGS
763	if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
764	s->intra_quant_bias = avctx->intra_quant_bias;
765	if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
766	s->inter_quant_bias = avctx->inter_quant_bias;
767	FF_ENABLE_DEPRECATION_WARNINGS
768	#endif
769
770	av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
771
772	if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
773	s->avctx->time_base.den > (1 << 16) - 1) {
774	av_log(avctx, AV_LOG_ERROR,
775	"timebase %d/%d not supported by MPEG 4 standard, "
776	"the maximum admitted value for the timebase denominator "
777	"is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
778	(1 << 16) - 1);
779	return -1;
780	}
781	s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
782
783	switch (avctx->codec->id) {
784	case AV_CODEC_ID_MPEG1VIDEO:
785	s->out_format = FMT_MPEG1;
786	s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
787	avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
788	break;
789	case AV_CODEC_ID_MPEG2VIDEO:
790	s->out_format = FMT_MPEG1;
791	s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
792	avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
793	s->rtp_mode = 1;
794	break;
795	case AV_CODEC_ID_MJPEG:
796	case AV_CODEC_ID_AMV:
797	s->out_format = FMT_MJPEG;
798	s->intra_only = 1; /* force intra only for jpeg */
799	if (!CONFIG_MJPEG_ENCODER ||
800	ff_mjpeg_encode_init(s) < 0)
801	return -1;
802	avctx->delay = 0;
803	s->low_delay = 1;
804	break;
805	case AV_CODEC_ID_H261:
806	if (!CONFIG_H261_ENCODER)
807	return -1;
808	if (ff_h261_get_picture_format(s->width, s->height) < 0) {
809	av_log(avctx, AV_LOG_ERROR,
810	"The specified picture size of %dx%d is not valid for the "
811	"H.261 codec.\nValid sizes are 176x144, 352x288\n",
812	s->width, s->height);
813	return -1;
814	}
815	s->out_format = FMT_H261;
816	avctx->delay = 0;
817	s->low_delay = 1;
818	s->rtp_mode = 0; /* Sliced encoding not supported */
819	break;
820	case AV_CODEC_ID_H263:
821	if (!CONFIG_H263_ENCODER)
822	return -1;
823	if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
824	s->width, s->height) == 8) {
825	av_log(avctx, AV_LOG_ERROR,
826	"The specified picture size of %dx%d is not valid for "
827	"the H.263 codec.\nValid sizes are 128x96, 176x144, "
828	"352x288, 704x576, and 1408x1152. "
829	"Try H.263+.\n", s->width, s->height);
830	return -1;
831	}
832	s->out_format = FMT_H263;
833	avctx->delay = 0;
834	s->low_delay = 1;
835	break;
836	case AV_CODEC_ID_H263P:
837	s->out_format = FMT_H263;
838	s->h263_plus = 1;
839	/* Fx */
840	s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
841	s->modified_quant = s->h263_aic;
842	s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
843	s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
844
845	/* /Fx */
846	/* These are just to be sure */
847	avctx->delay = 0;
848	s->low_delay = 1;
849	break;
850	case AV_CODEC_ID_FLV1:
851	s->out_format = FMT_H263;
852	s->h263_flv = 2; /* format = 1; 11-bit codes */
853	s->unrestricted_mv = 1;
854	s->rtp_mode = 0; /* don't allow GOB */
855	avctx->delay = 0;
856	s->low_delay = 1;
857	break;
858	case AV_CODEC_ID_RV10:
859	s->out_format = FMT_H263;
860	avctx->delay = 0;
861	s->low_delay = 1;
862	break;
863	case AV_CODEC_ID_RV20:
864	s->out_format = FMT_H263;
865	avctx->delay = 0;
866	s->low_delay = 1;
867	s->modified_quant = 1;
868	s->h263_aic = 1;
869	s->h263_plus = 1;
870	s->loop_filter = 1;
871	s->unrestricted_mv = 0;
872	break;
873	case AV_CODEC_ID_MPEG4:
874	s->out_format = FMT_H263;
875	s->h263_pred = 1;
876	s->unrestricted_mv = 1;
877	s->low_delay = s->max_b_frames ? 0 : 1;
878	avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
879	break;
880	case AV_CODEC_ID_MSMPEG4V2:
881	s->out_format = FMT_H263;
882	s->h263_pred = 1;
883	s->unrestricted_mv = 1;
884	s->msmpeg4_version = 2;
885	avctx->delay = 0;
886	s->low_delay = 1;
887	break;
888	case AV_CODEC_ID_MSMPEG4V3:
889	s->out_format = FMT_H263;
890	s->h263_pred = 1;
891	s->unrestricted_mv = 1;
892	s->msmpeg4_version = 3;
893	s->flipflop_rounding = 1;
894	avctx->delay = 0;
895	s->low_delay = 1;
896	break;
897	case AV_CODEC_ID_WMV1:
898	s->out_format = FMT_H263;
899	s->h263_pred = 1;
900	s->unrestricted_mv = 1;
901	s->msmpeg4_version = 4;
902	s->flipflop_rounding = 1;
903	avctx->delay = 0;
904	s->low_delay = 1;
905	break;
906	case AV_CODEC_ID_WMV2:
907	s->out_format = FMT_H263;
908	s->h263_pred = 1;
909	s->unrestricted_mv = 1;
910	s->msmpeg4_version = 5;
911	s->flipflop_rounding = 1;
912	avctx->delay = 0;
913	s->low_delay = 1;
914	break;
915	default:
916	return -1;
917	}
918
919	#if FF_API_PRIVATE_OPT
920	FF_DISABLE_DEPRECATION_WARNINGS
921	if (avctx->noise_reduction)
922	s->noise_reduction = avctx->noise_reduction;
923	FF_ENABLE_DEPRECATION_WARNINGS
924	#endif
925
926	avctx->has_b_frames = !s->low_delay;
927
928	s->encoding = 1;
929
930	s->progressive_frame =
931	s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
932	AV_CODEC_FLAG_INTERLACED_ME) ||
933	s->alternate_scan);
934
935	/* init */
936	ff_mpv_idct_init(s);
937	if (ff_mpv_common_init(s) < 0)
938	return -1;
939
940	ff_fdctdsp_init(&s->fdsp, avctx);
941	ff_me_cmp_init(&s->mecc, avctx);
942	ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
943	ff_pixblockdsp_init(&s->pdsp, avctx);
944	ff_qpeldsp_init(&s->qdsp);
945
946	if (s->msmpeg4_version) {
947	FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
948	2 * 2 * (MAX_LEVEL + 1) *
949	(MAX_RUN + 1) * 2 * sizeof(int), fail);
950	}
951	FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
952
953	FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
954	FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
955	FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
956	FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
957	FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
958	FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
959	FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
960	MAX_PICTURE_COUNT * sizeof(Picture *), fail);
961	FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
962	MAX_PICTURE_COUNT * sizeof(Picture *), fail);
963
964
965	if (s->noise_reduction) {
966	FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
967	2 * 64 * sizeof(uint16_t), fail);
968	}
969
970	ff_dct_encode_init(s);
971
972	if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
973	s->chroma_qscale_table = ff_h263_chroma_qscale_table;
974
975	if (s->slice_context_count > 1) {
976	s->rtp_mode = 1;
977
978	if (avctx->codec_id == AV_CODEC_ID_H263P)
979	s->h263_slice_structured = 1;
980	}
981
982	s->quant_precision = 5;
983
984	#if FF_API_PRIVATE_OPT
985	FF_DISABLE_DEPRECATION_WARNINGS
986	if (avctx->frame_skip_threshold)
987	s->frame_skip_threshold = avctx->frame_skip_threshold;
988	if (avctx->frame_skip_factor)
989	s->frame_skip_factor = avctx->frame_skip_factor;
990	if (avctx->frame_skip_exp)
991	s->frame_skip_exp = avctx->frame_skip_exp;
992	if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
993	s->frame_skip_cmp = avctx->frame_skip_cmp;
994	FF_ENABLE_DEPRECATION_WARNINGS
995	#endif
996
997	ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
998	ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
999
1000	if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
1001	ff_h261_encode_init(s);
1002	if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
1003	ff_h263_encode_init(s);
1004	if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
1005	if ((ret = ff_msmpeg4_encode_init(s)) < 0)
1006	return ret;
1007	if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
1008	&& s->out_format == FMT_MPEG1)
1009	ff_mpeg1_encode_init(s);
1010
1011	/* init q matrix */
1012	for (i = 0; i < 64; i++) {
1013	int j = s->idsp.idct_permutation[i];
1014	if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
1015	s->mpeg_quant) {
1016	s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1017	s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1018	} else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1019	s->intra_matrix[j] =
1020	s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1021	} else {
1022	/* MPEG-1/2 */
1023	s->chroma_intra_matrix[j] =
1024	s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1025	s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1026	}
1027	if (s->avctx->intra_matrix)
1028	s->intra_matrix[j] = s->avctx->intra_matrix[i];
1029	if (s->avctx->inter_matrix)
1030	s->inter_matrix[j] = s->avctx->inter_matrix[i];
1031	}
1032
1033	/* precompute matrix */
1034	/* for mjpeg, we do include qscale in the matrix */
1035	if (s->out_format != FMT_MJPEG) {
1036	ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
1037	s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1038	31, 1);
1039	ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
1040	s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1041	31, 0);
1042	}
1043
1044	#if FF_API_RC_STRATEGY
1045	FF_DISABLE_DEPRECATION_WARNINGS
1046	if (!s->rc_strategy)
1047	s->rc_strategy = s->avctx->rc_strategy;
1048	FF_ENABLE_DEPRECATION_WARNINGS
1049	#endif
1050
1051	if (ff_rate_control_init(s) < 0)
1052	return -1;
1053
1054	#if FF_API_RC_STRATEGY
1055	av_assert0(MPV_RC_STRATEGY_XVID == FF_RC_STRATEGY_XVID);
1056	#endif
1057
1058	if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID) {
1059	#if CONFIG_LIBXVID
1060	ret = ff_xvid_rate_control_init(s);
1061	#else
1062	ret = AVERROR(ENOSYS);
1063	av_log(s->avctx, AV_LOG_ERROR,
1064	"Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
1065	#endif
1066	if (ret < 0)
1067	return ret;
1068	}
1069
1070	#if FF_API_ERROR_RATE
1071	FF_DISABLE_DEPRECATION_WARNINGS
1072	if (avctx->error_rate)
1073	s->error_rate = avctx->error_rate;
1074	FF_ENABLE_DEPRECATION_WARNINGS;
1075	#endif
1076
1077	#if FF_API_NORMALIZE_AQP
1078	FF_DISABLE_DEPRECATION_WARNINGS
1079	if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
1080	s->mpv_flags |= FF_MPV_FLAG_NAQ;
1081	FF_ENABLE_DEPRECATION_WARNINGS;
1082	#endif
1083
1084	#if FF_API_MV0
1085	FF_DISABLE_DEPRECATION_WARNINGS
1086	if (avctx->flags & CODEC_FLAG_MV0)
1087	s->mpv_flags |= FF_MPV_FLAG_MV0;
1088	FF_ENABLE_DEPRECATION_WARNINGS
1089	#endif
1090
1091	#if FF_API_MPV_OPT
1092	FF_DISABLE_DEPRECATION_WARNINGS
1093	if (avctx->rc_qsquish != 0.0)
1094	s->rc_qsquish = avctx->rc_qsquish;
1095	if (avctx->rc_qmod_amp != 0.0)
1096	s->rc_qmod_amp = avctx->rc_qmod_amp;
1097	if (avctx->rc_qmod_freq)
1098	s->rc_qmod_freq = avctx->rc_qmod_freq;
1099	if (avctx->rc_buffer_aggressivity != 1.0)
1100	s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
1101	if (avctx->rc_initial_cplx != 0.0)
1102	s->rc_initial_cplx = avctx->rc_initial_cplx;
1103	if (avctx->lmin)
1104	s->lmin = avctx->lmin;
1105	if (avctx->lmax)
1106	s->lmax = avctx->lmax;
1107
1108	if (avctx->rc_eq) {
1109	av_freep(&s->rc_eq);
1110	s->rc_eq = av_strdup(avctx->rc_eq);
1111	if (!s->rc_eq)
1112	return AVERROR(ENOMEM);
1113	}
1114	FF_ENABLE_DEPRECATION_WARNINGS
1115	#endif
1116
1117	#if FF_API_PRIVATE_OPT
1118	FF_DISABLE_DEPRECATION_WARNINGS
1119	if (avctx->brd_scale)
1120	s->brd_scale = avctx->brd_scale;
1121
1122	if (avctx->prediction_method)
1123	s->pred = avctx->prediction_method + 1;
1124	FF_ENABLE_DEPRECATION_WARNINGS
1125	#endif
1126
1127	if (s->b_frame_strategy == 2) {
1128	for (i = 0; i < s->max_b_frames + 2; i++) {
1129	s->tmp_frames[i] = av_frame_alloc();
1130	if (!s->tmp_frames[i])
1131	return AVERROR(ENOMEM);
1132
1133	s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1134	s->tmp_frames[i]->width = s->width >> s->brd_scale;
1135	s->tmp_frames[i]->height = s->height >> s->brd_scale;
1136
1137	ret = av_frame_get_buffer(s->tmp_frames[i], 32);
1138	if (ret < 0)
1139	return ret;
1140	}
1141	}
1142
1143	cpb_props = ff_add_cpb_side_data(avctx);
1144	if (!cpb_props)
1145	return AVERROR(ENOMEM);
1146	cpb_props->max_bitrate = avctx->rc_max_rate;
1147	cpb_props->min_bitrate = avctx->rc_min_rate;
1148	cpb_props->avg_bitrate = avctx->bit_rate;
1149	cpb_props->buffer_size = avctx->rc_buffer_size;
1150
1151	return 0;
1152	fail:
1153	ff_mpv_encode_end(avctx);
1154	return AVERROR_UNKNOWN;
1155	}
1156
1157	av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1158	{
1159	MpegEncContext *s = avctx->priv_data;
1160	int i;
1161
1162	ff_rate_control_uninit(s);
1163	#if CONFIG_LIBXVID
1164	if ((avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
1165	ff_xvid_rate_control_uninit(s);
1166	#endif
1167
1168	ff_mpv_common_end(s);
1169	if (CONFIG_MJPEG_ENCODER &&
1170	s->out_format == FMT_MJPEG)
1171	ff_mjpeg_encode_close(s);
1172
1173	av_freep(&avctx->extradata);
1174
1175	for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1176	av_frame_free(&s->tmp_frames[i]);
1177
1178	ff_free_picture_tables(&s->new_picture);
1179	ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1180
1181	av_freep(&s->avctx->stats_out);
1182	av_freep(&s->ac_stats);
1183
1184	if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1185	if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1186	s->q_chroma_intra_matrix= NULL;
1187	s->q_chroma_intra_matrix16= NULL;
1188	av_freep(&s->q_intra_matrix);
1189	av_freep(&s->q_inter_matrix);
1190	av_freep(&s->q_intra_matrix16);
1191	av_freep(&s->q_inter_matrix16);
1192	av_freep(&s->input_picture);
1193	av_freep(&s->reordered_input_picture);
1194	av_freep(&s->dct_offset);
1195
1196	return 0;
1197	}
1198
1199	static int get_sae(uint8_t *src, int ref, int stride)
1200	{
1201	int x,y;
1202	int acc = 0;
1203
1204	for (y = 0; y < 16; y++) {
1205	for (x = 0; x < 16; x++) {
1206	acc += FFABS(src[x + y * stride] - ref);
1207	}
1208	}
1209
1210	return acc;
1211	}
1212
1213	static int get_intra_count(MpegEncContext *s, uint8_t *src,
1214	uint8_t *ref, int stride)
1215	{
1216	int x, y, w, h;
1217	int acc = 0;
1218
1219	w = s->width & ~15;
1220	h = s->height & ~15;
1221
1222	for (y = 0; y < h; y += 16) {
1223	for (x = 0; x < w; x += 16) {
1224	int offset = x + y * stride;
1225	int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1226	stride, 16);
1227	int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1228	int sae = get_sae(src + offset, mean, stride);
1229
1230	acc += sae + 500 < sad;
1231	}
1232	}
1233	return acc;
1234	}
1235
1236	static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1237	{
1238	return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1239	s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1240	s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1241	&s->linesize, &s->uvlinesize);
1242	}
1243
1244	static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1245	{
1246	Picture *pic = NULL;
1247	int64_t pts;
1248	int i, display_picture_number = 0, ret;
1249	int encoding_delay = s->max_b_frames ? s->max_b_frames
1250	: (s->low_delay ? 0 : 1);
1251	int flush_offset = 1;
1252	int direct = 1;
1253
1254	if (pic_arg) {
1255	pts = pic_arg->pts;
1256	display_picture_number = s->input_picture_number++;
1257
1258	if (pts != AV_NOPTS_VALUE) {
1259	if (s->user_specified_pts != AV_NOPTS_VALUE) {
1260	int64_t last = s->user_specified_pts;
1261
1262	if (pts <= last) {
1263	av_log(s->avctx, AV_LOG_ERROR,
1264	"Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1265	pts, last);
1266	return AVERROR(EINVAL);
1267	}
1268
1269	if (!s->low_delay && display_picture_number == 1)
1270	s->dts_delta = pts - last;
1271	}
1272	s->user_specified_pts = pts;
1273	} else {
1274	if (s->user_specified_pts != AV_NOPTS_VALUE) {
1275	s->user_specified_pts =
1276	pts = s->user_specified_pts + 1;
1277	av_log(s->avctx, AV_LOG_INFO,
1278	"Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1279	pts);
1280	} else {
1281	pts = display_picture_number;
1282	}
1283	}
1284
1285	if (!pic_arg->buf[0] ||
1286	pic_arg->linesize[0] != s->linesize ||
1287	pic_arg->linesize[1] != s->uvlinesize ||
1288	pic_arg->linesize[2] != s->uvlinesize)
1289	direct = 0;
1290	if ((s->width & 15) || (s->height & 15))
1291	direct = 0;
1292	if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1293	direct = 0;
1294	if (s->linesize & (STRIDE_ALIGN-1))
1295	direct = 0;
1296
1297	ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1298	pic_arg->linesize[1], s->linesize, s->uvlinesize);
1299
1300	i = ff_find_unused_picture(s->avctx, s->picture, direct);
1301	if (i < 0)
1302	return i;
1303
1304	pic = &s->picture[i];
1305	pic->reference = 3;
1306
1307	if (direct) {
1308	if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1309	return ret;
1310	}
1311	ret = alloc_picture(s, pic, direct);
1312	if (ret < 0)
1313	return ret;
1314
1315	if (!direct) {
1316	if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1317	pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1318	pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1319	// empty
1320	} else {
1321	int h_chroma_shift, v_chroma_shift;
1322	av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1323	&h_chroma_shift,
1324	&v_chroma_shift);
1325
1326	for (i = 0; i < 3; i++) {
1327	int src_stride = pic_arg->linesize[i];
1328	int dst_stride = i ? s->uvlinesize : s->linesize;
1329	int h_shift = i ? h_chroma_shift : 0;
1330	int v_shift = i ? v_chroma_shift : 0;
1331	int w = s->width >> h_shift;
1332	int h = s->height >> v_shift;
1333	uint8_t *src = pic_arg->data[i];
1334	uint8_t *dst = pic->f->data[i];
1335	int vpad = 16;
1336
1337	if ( s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1338	&& !s->progressive_sequence
1339	&& FFALIGN(s->height, 32) - s->height > 16)
1340	vpad = 32;
1341
1342	if (!s->avctx->rc_buffer_size)
1343	dst += INPLACE_OFFSET;
1344
1345	if (src_stride == dst_stride)
1346	memcpy(dst, src, src_stride * h);
1347	else {
1348	int h2 = h;
1349	uint8_t *dst2 = dst;
1350	while (h2--) {
1351	memcpy(dst2, src, w);
1352	dst2 += dst_stride;
1353	src += src_stride;
1354	}
1355	}
1356	if ((s->width & 15) || (s->height & (vpad-1))) {
1357	s->mpvencdsp.draw_edges(dst, dst_stride,
1358	w, h,
1359	16 >> h_shift,
1360	vpad >> v_shift,
1361	EDGE_BOTTOM);
1362	}
1363	}
1364	emms_c();
1365	}
1366	}
1367	ret = av_frame_copy_props(pic->f, pic_arg);
1368	if (ret < 0)
1369	return ret;
1370
1371	pic->f->display_picture_number = display_picture_number;
1372	pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1373	} else {
1374	/* Flushing: When we have not received enough input frames,
1375	* ensure s->input_picture[0] contains the first picture */
1376	for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1377	if (s->input_picture[flush_offset])
1378	break;
1379
1380	if (flush_offset <= 1)
1381	flush_offset = 1;
1382	else
1383	encoding_delay = encoding_delay - flush_offset + 1;
1384	}
1385
1386	/* shift buffer entries */
1387	for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1388	s->input_picture[i - flush_offset] = s->input_picture[i];
1389
1390	s->input_picture[encoding_delay] = (Picture*) pic;
1391
1392	return 0;
1393	}
1394
1395	static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1396	{
1397	int x, y, plane;
1398	int score = 0;
1399	int64_t score64 = 0;
1400
1401	for (plane = 0; plane < 3; plane++) {
1402	const int stride = p->f->linesize[plane];
1403	const int bw = plane ? 1 : 2;
1404	for (y = 0; y < s->mb_height * bw; y++) {
1405	for (x = 0; x < s->mb_width * bw; x++) {
1406	int off = p->shared ? 0 : 16;
1407	uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1408	uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1409	int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1410
1411	switch (FFABS(s->frame_skip_exp)) {
1412	case 0: score = FFMAX(score, v); break;
1413	case 1: score += FFABS(v); break;
1414	case 2: score64 += v * (int64_t)v; break;
1415	case 3: score64 += FFABS(v * (int64_t)v * v); break;
1416	case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1417	}
1418	}
1419	}
1420	}
1421	emms_c();
1422
1423	if (score)
1424	score64 = score;
1425	if (s->frame_skip_exp < 0)
1426	score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1427	-1.0/s->frame_skip_exp);
1428
1429	if (score64 < s->frame_skip_threshold)
1430	return 1;
1431	if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1432	return 1;
1433	return 0;
1434	}
1435
1436	static int encode_frame(AVCodecContext *c, AVFrame *frame)
1437	{
1438	AVPacket pkt = { 0 };
1439	int ret;
1440	int size = 0;
1441
1442	av_init_packet(&pkt);
1443
1444	ret = avcodec_send_frame(c, frame);
1445	if (ret < 0)
1446	return ret;
1447
1448	do {
1449	ret = avcodec_receive_packet(c, &pkt);
1450	if (ret >= 0) {
1451	size += pkt.size;
1452	av_packet_unref(&pkt);
1453	} else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1454	return ret;
1455	} while (ret >= 0);
1456
1457	return size;
1458	}
1459
1460	static int estimate_best_b_count(MpegEncContext *s)
1461	{
1462	const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1463	const int scale = s->brd_scale;
1464	int width = s->width >> scale;
1465	int height = s->height >> scale;
1466	int i, j, out_size, p_lambda, b_lambda, lambda2;
1467	int64_t best_rd = INT64_MAX;
1468	int best_b_count = -1;
1469	int ret = 0;
1470
1471	av_assert0(scale >= 0 && scale <= 3);
1472
1473	//emms_c();
1474	//s->next_picture_ptr->quality;
1475	p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1476	//p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1477	b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1478	if (!b_lambda) // FIXME we should do this somewhere else
1479	b_lambda = p_lambda;
1480	lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1481	FF_LAMBDA_SHIFT;
1482
1483	for (i = 0; i < s->max_b_frames + 2; i++) {
1484	Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1485	s->next_picture_ptr;
1486	uint8_t *data[4];
1487
1488	if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1489	pre_input = *pre_input_ptr;
1490	memcpy(data, pre_input_ptr->f->data, sizeof(data));
1491
1492	if (!pre_input.shared && i) {
1493	data[0] += INPLACE_OFFSET;
1494	data[1] += INPLACE_OFFSET;
1495	data[2] += INPLACE_OFFSET;
1496	}
1497
1498	s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1499	s->tmp_frames[i]->linesize[0],
1500	data[0],
1501	pre_input.f->linesize[0],
1502	width, height);
1503	s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1504	s->tmp_frames[i]->linesize[1],
1505	data[1],
1506	pre_input.f->linesize[1],
1507	width >> 1, height >> 1);
1508	s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1509	s->tmp_frames[i]->linesize[2],
1510	data[2],
1511	pre_input.f->linesize[2],
1512	width >> 1, height >> 1);
1513	}
1514	}
1515
1516	for (j = 0; j < s->max_b_frames + 1; j++) {
1517	AVCodecContext *c;
1518	int64_t rd = 0;
1519
1520	if (!s->input_picture[j])
1521	break;
1522
1523	c = avcodec_alloc_context3(NULL);
1524	if (!c)
1525	return AVERROR(ENOMEM);
1526
1527	c->width = width;
1528	c->height = height;
1529	c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1530	c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1531	c->mb_decision = s->avctx->mb_decision;
1532	c->me_cmp = s->avctx->me_cmp;
1533	c->mb_cmp = s->avctx->mb_cmp;
1534	c->me_sub_cmp = s->avctx->me_sub_cmp;
1535	c->pix_fmt = AV_PIX_FMT_YUV420P;
1536	c->time_base = s->avctx->time_base;
1537	c->max_b_frames = s->max_b_frames;
1538
1539	ret = avcodec_open2(c, codec, NULL);
1540	if (ret < 0)
1541	goto fail;
1542
1543	s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1544	s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1545
1546	out_size = encode_frame(c, s->tmp_frames[0]);
1547	if (out_size < 0) {
1548	ret = out_size;
1549	goto fail;
1550	}
1551
1552	//rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1553
1554	for (i = 0; i < s->max_b_frames + 1; i++) {
1555	int is_p = i % (j + 1) == j || i == s->max_b_frames;
1556
1557	s->tmp_frames[i + 1]->pict_type = is_p ?
1558	AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1559	s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1560
1561	out_size = encode_frame(c, s->tmp_frames[i + 1]);
1562	if (out_size < 0) {
1563	ret = out_size;
1564	goto fail;
1565	}
1566
1567	rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1568	}
1569
1570	/* get the delayed frames */
1571	out_size = encode_frame(c, NULL);
1572	if (out_size < 0) {
1573	ret = out_size;
1574	goto fail;
1575	}
1576	rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1577
1578	rd += c->error[0] + c->error[1] + c->error[2];
1579
1580	if (rd < best_rd) {
1581	best_rd = rd;
1582	best_b_count = j;
1583	}
1584
1585	fail:
1586	avcodec_free_context(&c);
1587	if (ret < 0)
1588	return ret;
1589	}
1590
1591	return best_b_count;
1592	}
1593
1594	static int select_input_picture(MpegEncContext *s)
1595	{
1596	int i, ret;
1597
1598	for (i = 1; i < MAX_PICTURE_COUNT; i++)
1599	s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1600	s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1601
1602	/* set next picture type & ordering */
1603	if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1604	if (s->frame_skip_threshold || s->frame_skip_factor) {
1605	if (s->picture_in_gop_number < s->gop_size &&
1606	s->next_picture_ptr &&
1607	skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1608	// FIXME check that the gop check above is +-1 correct
1609	av_frame_unref(s->input_picture[0]->f);
1610
1611	ff_vbv_update(s, 0);
1612
1613	goto no_output_pic;
1614	}
1615	}
1616
1617	if (/*s->picture_in_gop_number >= s->gop_size ||*/
1618	!s->next_picture_ptr || s->intra_only) {
1619	s->reordered_input_picture[0] = s->input_picture[0];
1620	s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1621	s->reordered_input_picture[0]->f->coded_picture_number =
1622	s->coded_picture_number++;
1623	} else {
1624	int b_frames = 0;
1625
1626	if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1627	for (i = 0; i < s->max_b_frames + 1; i++) {
1628	int pict_num = s->input_picture[0]->f->display_picture_number + i;
1629
1630	if (pict_num >= s->rc_context.num_entries)
1631	break;
1632	if (!s->input_picture[i]) {
1633	s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1634	break;
1635	}
1636
1637	s->input_picture[i]->f->pict_type =
1638	s->rc_context.entry[pict_num].new_pict_type;
1639	}
1640	}
1641
1642	if (s->b_frame_strategy == 0) {
1643	b_frames = s->max_b_frames;
1644	while (b_frames && !s->input_picture[b_frames])
1645	b_frames--;
1646	} else if (s->b_frame_strategy == 1) {
1647	for (i = 1; i < s->max_b_frames + 1; i++) {
1648	if (s->input_picture[i] &&
1649	s->input_picture[i]->b_frame_score == 0) {
1650	s->input_picture[i]->b_frame_score =
1651	get_intra_count(s,
1652	s->input_picture[i ]->f->data[0],
1653	s->input_picture[i - 1]->f->data[0],
1654	s->linesize) + 1;
1655	}
1656	}
1657	for (i = 0; i < s->max_b_frames + 1; i++) {
1658	if (!s->input_picture[i] ||
1659	s->input_picture[i]->b_frame_score - 1 >
1660	s->mb_num / s->b_sensitivity)
1661	break;
1662	}
1663
1664	b_frames = FFMAX(0, i - 1);
1665
1666	/* reset scores */
1667	for (i = 0; i < b_frames + 1; i++) {
1668	s->input_picture[i]->b_frame_score = 0;
1669	}
1670	} else if (s->b_frame_strategy == 2) {
1671	b_frames = estimate_best_b_count(s);
1672	if (b_frames < 0)
1673	return b_frames;
1674	}
1675
1676	emms_c();
1677
1678	for (i = b_frames - 1; i >= 0; i--) {
1679	int type = s->input_picture[i]->f->pict_type;
1680	if (type && type != AV_PICTURE_TYPE_B)
1681	b_frames = i;
1682	}
1683	if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1684	b_frames == s->max_b_frames) {
1685	av_log(s->avctx, AV_LOG_ERROR,
1686	"warning, too many B-frames in a row\n");
1687	}
1688
1689	if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1690	if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1691	s->gop_size > s->picture_in_gop_number) {
1692	b_frames = s->gop_size - s->picture_in_gop_number - 1;
1693	} else {
1694	if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1695	b_frames = 0;
1696	s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1697	}
1698	}
1699
1700	if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1701	s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1702	b_frames--;
1703
1704	s->reordered_input_picture[0] = s->input_picture[b_frames];
1705	if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1706	s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1707	s->reordered_input_picture[0]->f->coded_picture_number =
1708	s->coded_picture_number++;
1709	for (i = 0; i < b_frames; i++) {
1710	s->reordered_input_picture[i + 1] = s->input_picture[i];
1711	s->reordered_input_picture[i + 1]->f->pict_type =
1712	AV_PICTURE_TYPE_B;
1713	s->reordered_input_picture[i + 1]->f->coded_picture_number =
1714	s->coded_picture_number++;
1715	}
1716	}
1717	}
1718	no_output_pic:
1719	ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1720
1721	if (s->reordered_input_picture[0]) {
1722	s->reordered_input_picture[0]->reference =
1723	s->reordered_input_picture[0]->f->pict_type !=
1724	AV_PICTURE_TYPE_B ? 3 : 0;
1725
1726	if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1727	return ret;
1728
1729	if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1730	// input is a shared pix, so we can't modify it -> allocate a new
1731	// one & ensure that the shared one is reuseable
1732
1733	Picture *pic;
1734	int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1735	if (i < 0)
1736	return i;
1737	pic = &s->picture[i];
1738
1739	pic->reference = s->reordered_input_picture[0]->reference;
1740	if (alloc_picture(s, pic, 0) < 0) {
1741	return -1;
1742	}
1743
1744	ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1745	if (ret < 0)
1746	return ret;
1747
1748	/* mark us unused / free shared pic */
1749	av_frame_unref(s->reordered_input_picture[0]->f);
1750	s->reordered_input_picture[0]->shared = 0;
1751
1752	s->current_picture_ptr = pic;
1753	} else {
1754	// input is not a shared pix -> reuse buffer for current_pix
1755	s->current_picture_ptr = s->reordered_input_picture[0];
1756	for (i = 0; i < 4; i++) {
1757	s->new_picture.f->data[i] += INPLACE_OFFSET;
1758	}
1759	}
1760	ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1761	if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1762	s->current_picture_ptr)) < 0)
1763	return ret;
1764
1765	s->picture_number = s->new_picture.f->display_picture_number;
1766	}
1767	return 0;
1768	}
1769
1770	static void frame_end(MpegEncContext *s)
1771	{
1772	if (s->unrestricted_mv &&
1773	s->current_picture.reference &&
1774	!s->intra_only) {
1775	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1776	int hshift = desc->log2_chroma_w;
1777	int vshift = desc->log2_chroma_h;
1778	s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
1779	s->current_picture.f->linesize[0],
1780	s->h_edge_pos, s->v_edge_pos,
1781	EDGE_WIDTH, EDGE_WIDTH,
1782	EDGE_TOP | EDGE_BOTTOM);
1783	s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
1784	s->current_picture.f->linesize[1],
1785	s->h_edge_pos >> hshift,
1786	s->v_edge_pos >> vshift,
1787	EDGE_WIDTH >> hshift,
1788	EDGE_WIDTH >> vshift,
1789	EDGE_TOP | EDGE_BOTTOM);
1790	s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
1791	s->current_picture.f->linesize[2],
1792	s->h_edge_pos >> hshift,
1793	s->v_edge_pos >> vshift,
1794	EDGE_WIDTH >> hshift,
1795	EDGE_WIDTH >> vshift,
1796	EDGE_TOP | EDGE_BOTTOM);
1797	}
1798
1799	emms_c();
1800
1801	s->last_pict_type = s->pict_type;
1802	s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1803	if (s->pict_type!= AV_PICTURE_TYPE_B)
1804	s->last_non_b_pict_type = s->pict_type;
1805
1806	#if FF_API_CODED_FRAME
1807	FF_DISABLE_DEPRECATION_WARNINGS
1808	av_frame_unref(s->avctx->coded_frame);
1809	av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1810	FF_ENABLE_DEPRECATION_WARNINGS
1811	#endif
1812	#if FF_API_ERROR_FRAME
1813	FF_DISABLE_DEPRECATION_WARNINGS
1814	memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1815	sizeof(s->current_picture.encoding_error));
1816	FF_ENABLE_DEPRECATION_WARNINGS
1817	#endif
1818	}
1819
1820	static void update_noise_reduction(MpegEncContext *s)
1821	{
1822	int intra, i;
1823
1824	for (intra = 0; intra < 2; intra++) {
1825	if (s->dct_count[intra] > (1 << 16)) {
1826	for (i = 0; i < 64; i++) {
1827	s->dct_error_sum[intra][i] >>= 1;
1828	}
1829	s->dct_count[intra] >>= 1;
1830	}
1831
1832	for (i = 0; i < 64; i++) {
1833	s->dct_offset[intra][i] = (s->noise_reduction *
1834	s->dct_count[intra] +
1835	s->dct_error_sum[intra][i] / 2) /
1836	(s->dct_error_sum[intra][i] + 1);
1837	}
1838	}
1839	}
1840
1841	static int frame_start(MpegEncContext *s)
1842	{
1843	int ret;
1844
1845	/* mark & release old frames */
1846	if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1847	s->last_picture_ptr != s->next_picture_ptr &&
1848	s->last_picture_ptr->f->buf[0]) {
1849	ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1850	}
1851
1852	s->current_picture_ptr->f->pict_type = s->pict_type;
1853	s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1854
1855	ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1856	if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1857	s->current_picture_ptr)) < 0)
1858	return ret;
1859
1860	if (s->pict_type != AV_PICTURE_TYPE_B) {
1861	s->last_picture_ptr = s->next_picture_ptr;
1862	if (!s->droppable)
1863	s->next_picture_ptr = s->current_picture_ptr;
1864	}
1865
1866	if (s->last_picture_ptr) {
1867	ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1868	if (s->last_picture_ptr->f->buf[0] &&
1869	(ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1870	s->last_picture_ptr)) < 0)
1871	return ret;
1872	}
1873	if (s->next_picture_ptr) {
1874	ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1875	if (s->next_picture_ptr->f->buf[0] &&
1876	(ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1877	s->next_picture_ptr)) < 0)
1878	return ret;
1879	}
1880
1881	if (s->picture_structure!= PICT_FRAME) {
1882	int i;
1883	for (i = 0; i < 4; i++) {
1884	if (s->picture_structure == PICT_BOTTOM_FIELD) {
1885	s->current_picture.f->data[i] +=
1886	s->current_picture.f->linesize[i];
1887	}
1888	s->current_picture.f->linesize[i] *= 2;
1889	s->last_picture.f->linesize[i] *= 2;
1890	s->next_picture.f->linesize[i] *= 2;
1891	}
1892	}
1893
1894	if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1895	s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1896	s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1897	} else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1898	s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1899	s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1900	} else {
1901	s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1902	s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1903	}
1904
1905	if (s->dct_error_sum) {
1906	av_assert2(s->noise_reduction && s->encoding);
1907	update_noise_reduction(s);
1908	}
1909
1910	return 0;
1911	}
1912
1913	int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1914	const AVFrame *pic_arg, int *got_packet)
1915	{
1916	MpegEncContext *s = avctx->priv_data;
1917	int i, stuffing_count, ret;
1918	int context_count = s->slice_context_count;
1919
1920	s->vbv_ignore_qmax = 0;
1921
1922	s->picture_in_gop_number++;
1923
1924	if (load_input_picture(s, pic_arg) < 0)
1925	return -1;
1926
1927	if (select_input_picture(s) < 0) {
1928	return -1;
1929	}
1930
1931	/* output? */
1932	if (s->new_picture.f->data[0]) {
1933	int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1934	int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1935	:
1936	s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1937	if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1938	return ret;
1939	if (s->mb_info) {
1940	s->mb_info_ptr = av_packet_new_side_data(pkt,
1941	AV_PKT_DATA_H263_MB_INFO,
1942	s->mb_width*s->mb_height*12);
1943	s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1944	}
1945
1946	for (i = 0; i < context_count; i++) {
1947	int start_y = s->thread_context[i]->start_mb_y;
1948	int end_y = s->thread_context[i]-> end_mb_y;
1949	int h = s->mb_height;
1950	uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1951	uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1952
1953	init_put_bits(&s->thread_context[i]->pb, start, end - start);
1954	}
1955
1956	s->pict_type = s->new_picture.f->pict_type;
1957	//emms_c();
1958	ret = frame_start(s);
1959	if (ret < 0)
1960	return ret;
1961	vbv_retry:
1962	ret = encode_picture(s, s->picture_number);
1963	if (growing_buffer) {
1964	av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1965	pkt->data = s->pb.buf;
1966	pkt->size = avctx->internal->byte_buffer_size;
1967	}
1968	if (ret < 0)
1969	return -1;
1970
1971	#if FF_API_STAT_BITS
1972	FF_DISABLE_DEPRECATION_WARNINGS
1973	avctx->header_bits = s->header_bits;
1974	avctx->mv_bits = s->mv_bits;
1975	avctx->misc_bits = s->misc_bits;
1976	avctx->i_tex_bits = s->i_tex_bits;
1977	avctx->p_tex_bits = s->p_tex_bits;
1978	avctx->i_count = s->i_count;
1979	// FIXME f/b_count in avctx
1980	avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1981	avctx->skip_count = s->skip_count;
1982	FF_ENABLE_DEPRECATION_WARNINGS
1983	#endif
1984
1985	frame_end(s);
1986
1987	if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1988	ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1989
1990	if (avctx->rc_buffer_size) {
1991	RateControlContext *rcc = &s->rc_context;
1992	int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1993	int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1994	int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1995
1996	if (put_bits_count(&s->pb) > max_size &&
1997	s->lambda < s->lmax) {
1998	s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1999	(s->qscale + 1) / s->qscale);
2000	if (s->adaptive_quant) {
2001	int i;
2002	for (i = 0; i < s->mb_height * s->mb_stride; i++)
2003	s->lambda_table[i] =
2004	FFMAX(s->lambda_table[i] + min_step,
2005	s->lambda_table[i] * (s->qscale + 1) /
2006	s->qscale);
2007	}
2008	s->mb_skipped = 0; // done in frame_start()
2009	// done in encode_picture() so we must undo it
2010	if (s->pict_type == AV_PICTURE_TYPE_P) {
2011	if (s->flipflop_rounding ||
2012	s->codec_id == AV_CODEC_ID_H263P ||
2013	s->codec_id == AV_CODEC_ID_MPEG4)
2014	s->no_rounding ^= 1;
2015	}
2016	if (s->pict_type != AV_PICTURE_TYPE_B) {
2017	s->time_base = s->last_time_base;
2018	s->last_non_b_time = s->time - s->pp_time;
2019	}
2020	for (i = 0; i < context_count; i++) {
2021	PutBitContext *pb = &s->thread_context[i]->pb;
2022	init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2023	}
2024	s->vbv_ignore_qmax = 1;
2025	av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
2026	goto vbv_retry;
2027	}
2028
2029	av_assert0(s->avctx->rc_max_rate);
2030	}
2031
2032	if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
2033	ff_write_pass1_stats(s);
2034
2035	for (i = 0; i < 4; i++) {
2036	s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
2037	avctx->error[i] += s->current_picture_ptr->encoding_error[i];
2038	}
2039	ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
2040	s->current_picture_ptr->encoding_error,
2041	(s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
2042	s->pict_type);
2043
2044	if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
2045	assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
2046	s->misc_bits + s->i_tex_bits +
2047	s->p_tex_bits);
2048	flush_put_bits(&s->pb);
2049	s->frame_bits = put_bits_count(&s->pb);
2050
2051	stuffing_count = ff_vbv_update(s, s->frame_bits);
2052	s->stuffing_bits = 8*stuffing_count;
2053	if (stuffing_count) {
2054	if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
2055	stuffing_count + 50) {
2056	av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2057	return -1;
2058	}
2059
2060	switch (s->codec_id) {
2061	case AV_CODEC_ID_MPEG1VIDEO:
2062	case AV_CODEC_ID_MPEG2VIDEO:
2063	while (stuffing_count--) {
2064	put_bits(&s->pb, 8, 0);
2065	}
2066	break;
2067	case AV_CODEC_ID_MPEG4:
2068	put_bits(&s->pb, 16, 0);
2069	put_bits(&s->pb, 16, 0x1C3);
2070	stuffing_count -= 4;
2071	while (stuffing_count--) {
2072	put_bits(&s->pb, 8, 0xFF);
2073	}
2074	break;
2075	default:
2076	av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2077	}
2078	flush_put_bits(&s->pb);
2079	s->frame_bits = put_bits_count(&s->pb);
2080	}
2081
2082	/* update MPEG-1/2 vbv_delay for CBR */
2083	if (s->avctx->rc_max_rate &&
2084	s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
2085	s->out_format == FMT_MPEG1 &&
2086	90000LL * (avctx->rc_buffer_size - 1) <=
2087	s->avctx->rc_max_rate * 0xFFFFLL) {
2088	AVCPBProperties *props;
2089	size_t props_size;
2090
2091	int vbv_delay, min_delay;
2092	double inbits = s->avctx->rc_max_rate *
2093	av_q2d(s->avctx->time_base);
2094	int minbits = s->frame_bits - 8 *
2095	(s->vbv_delay_ptr - s->pb.buf - 1);
2096	double bits = s->rc_context.buffer_index + minbits - inbits;
2097
2098	if (bits < 0)
2099	av_log(s->avctx, AV_LOG_ERROR,
2100	"Internal error, negative bits\n");
2101
2102	assert(s->repeat_first_field == 0);
2103
2104	vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
2105	min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
2106	s->avctx->rc_max_rate;
2107
2108	vbv_delay = FFMAX(vbv_delay, min_delay);
2109
2110	av_assert0(vbv_delay < 0xFFFF);
2111
2112	s->vbv_delay_ptr[0] &= 0xF8;
2113	s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2114	s->vbv_delay_ptr[1] = vbv_delay >> 5;
2115	s->vbv_delay_ptr[2] &= 0x07;
2116	s->vbv_delay_ptr[2] |= vbv_delay << 3;
2117
2118	props = av_cpb_properties_alloc(&props_size);
2119	if (!props)
2120	return AVERROR(ENOMEM);
2121	props->vbv_delay = vbv_delay * 300;
2122
2123	ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2124	(uint8_t*)props, props_size);
2125	if (ret < 0) {
2126	av_freep(&props);
2127	return ret;
2128	}
2129
2130	#if FF_API_VBV_DELAY
2131	FF_DISABLE_DEPRECATION_WARNINGS
2132	avctx->vbv_delay = vbv_delay * 300;
2133	FF_ENABLE_DEPRECATION_WARNINGS
2134	#endif
2135	}
2136	s->total_bits += s->frame_bits;
2137	#if FF_API_STAT_BITS
2138	FF_DISABLE_DEPRECATION_WARNINGS
2139	avctx->frame_bits = s->frame_bits;
2140	FF_ENABLE_DEPRECATION_WARNINGS
2141	#endif
2142
2143
2144	pkt->pts = s->current_picture.f->pts;
2145	if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2146	if (!s->current_picture.f->coded_picture_number)
2147	pkt->dts = pkt->pts - s->dts_delta;
2148	else
2149	pkt->dts = s->reordered_pts;
2150	s->reordered_pts = pkt->pts;
2151	} else
2152	pkt->dts = pkt->pts;
2153	if (s->current_picture.f->key_frame)
2154	pkt->flags |= AV_PKT_FLAG_KEY;
2155	if (s->mb_info)
2156	av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2157	} else {
2158	s->frame_bits = 0;
2159	}
2160
2161	/* release non-reference frames */
2162	for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2163	if (!s->picture[i].reference)
2164	ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2165	}
2166
2167	av_assert1((s->frame_bits & 7) == 0);
2168
2169	pkt->size = s->frame_bits / 8;
2170	*got_packet = !!pkt->size;
2171	return 0;
2172	}
2173
2174	static inline void dct_single_coeff_elimination(MpegEncContext *s,
2175	int n, int threshold)
2176	{
2177	static const char tab[64] = {
2178	3, 2, 2, 1, 1, 1, 1, 1,
2179	1, 1, 1, 1, 1, 1, 1, 1,
2180	1, 1, 1, 1, 1, 1, 1, 1,
2181	0, 0, 0, 0, 0, 0, 0, 0,
2182	0, 0, 0, 0, 0, 0, 0, 0,
2183	0, 0, 0, 0, 0, 0, 0, 0,
2184	0, 0, 0, 0, 0, 0, 0, 0,
2185	0, 0, 0, 0, 0, 0, 0, 0
2186	};
2187	int score = 0;
2188	int run = 0;
2189	int i;
2190	int16_t *block = s->block[n];
2191	const int last_index = s->block_last_index[n];
2192	int skip_dc;
2193
2194	if (threshold < 0) {
2195	skip_dc = 0;
2196	threshold = -threshold;
2197	} else
2198	skip_dc = 1;
2199
2200	/* Are all we could set to zero already zero? */
2201	if (last_index <= skip_dc - 1)
2202	return;
2203
2204	for (i = 0; i <= last_index; i++) {
2205	const int j = s->intra_scantable.permutated[i];
2206	const int level = FFABS(block[j]);
2207	if (level == 1) {
2208	if (skip_dc && i == 0)
2209	continue;
2210	score += tab[run];
2211	run = 0;
2212	} else if (level > 1) {
2213	return;
2214	} else {
2215	run++;
2216	}
2217	}
2218	if (score >= threshold)
2219	return;
2220	for (i = skip_dc; i <= last_index; i++) {
2221	const int j = s->intra_scantable.permutated[i];
2222	block[j] = 0;
2223	}
2224	if (block[0])
2225	s->block_last_index[n] = 0;
2226	else
2227	s->block_last_index[n] = -1;
2228	}
2229
2230	static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2231	int last_index)
2232	{
2233	int i;
2234	const int maxlevel = s->max_qcoeff;
2235	const int minlevel = s->min_qcoeff;
2236	int overflow = 0;
2237
2238	if (s->mb_intra) {
2239	i = 1; // skip clipping of intra dc
2240	} else
2241	i = 0;
2242
2243	for (; i <= last_index; i++) {
2244	const int j = s->intra_scantable.permutated[i];
2245	int level = block[j];
2246
2247	if (level > maxlevel) {
2248	level = maxlevel;
2249	overflow++;
2250	} else if (level < minlevel) {
2251	level = minlevel;
2252	overflow++;
2253	}
2254
2255	block[j] = level;
2256	}
2257
2258	if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2259	av_log(s->avctx, AV_LOG_INFO,
2260	"warning, clipping %d dct coefficients to %d..%d\n",
2261	overflow, minlevel, maxlevel);
2262	}
2263
2264	static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2265	{
2266	int x, y;
2267	// FIXME optimize
2268	for (y = 0; y < 8; y++) {
2269	for (x = 0; x < 8; x++) {
2270	int x2, y2;
2271	int sum = 0;
2272	int sqr = 0;
2273	int count = 0;
2274
2275	for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2276	for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2277	int v = ptr[x2 + y2 * stride];
2278	sum += v;
2279	sqr += v * v;
2280	count++;
2281	}
2282	}
2283	weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2284	}
2285	}
2286	}
2287
2288	static av_always_inline void encode_mb_internal(MpegEncContext *s,
2289	int motion_x, int motion_y,
2290	int mb_block_height,
2291	int mb_block_width,
2292	int mb_block_count)
2293	{
2294	int16_t weight[12][64];
2295	int16_t orig[12][64];
2296	const int mb_x = s->mb_x;
2297	const int mb_y = s->mb_y;
2298	int i;
2299	int skip_dct[12];
2300	int dct_offset = s->linesize * 8; // default for progressive frames
2301	int uv_dct_offset = s->uvlinesize * 8;
2302	uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2303	ptrdiff_t wrap_y, wrap_c;
2304
2305	for (i = 0; i < mb_block_count; i++)
2306	skip_dct[i] = s->skipdct;
2307
2308	if (s->adaptive_quant) {
2309	const int last_qp = s->qscale;
2310	const int mb_xy = mb_x + mb_y * s->mb_stride;
2311
2312	s->lambda = s->lambda_table[mb_xy];
2313	update_qscale(s);
2314
2315	if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2316	s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2317	s->dquant = s->qscale - last_qp;
2318
2319	if (s->out_format == FMT_H263) {
2320	s->dquant = av_clip(s->dquant, -2, 2);
2321
2322	if (s->codec_id == AV_CODEC_ID_MPEG4) {
2323	if (!s->mb_intra) {
2324	if (s->pict_type == AV_PICTURE_TYPE_B) {
2325	if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2326	s->dquant = 0;
2327	}
2328	if (s->mv_type == MV_TYPE_8X8)
2329	s->dquant = 0;
2330	}
2331	}
2332	}
2333	}
2334	ff_set_qscale(s, last_qp + s->dquant);
2335	} else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2336	ff_set_qscale(s, s->qscale + s->dquant);
2337
2338	wrap_y = s->linesize;
2339	wrap_c = s->uvlinesize;
2340	ptr_y = s->new_picture.f->data[0] +
2341	(mb_y * 16 * wrap_y) + mb_x * 16;
2342	ptr_cb = s->new_picture.f->data[1] +
2343	(mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2344	ptr_cr = s->new_picture.f->data[2] +
2345	(mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2346
2347	if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2348	uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2349	int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2350	int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2351	s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2352	wrap_y, wrap_y,
2353	16, 16, mb_x * 16, mb_y * 16,
2354	s->width, s->height);
2355	ptr_y = ebuf;
2356	s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2357	wrap_c, wrap_c,
2358	mb_block_width, mb_block_height,
2359	mb_x * mb_block_width, mb_y * mb_block_height,
2360	cw, ch);
2361	ptr_cb = ebuf + 16 * wrap_y;
2362	s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2363	wrap_c, wrap_c,
2364	mb_block_width, mb_block_height,
2365	mb_x * mb_block_width, mb_y * mb_block_height,
2366	cw, ch);
2367	ptr_cr = ebuf + 16 * wrap_y + 16;
2368	}
2369
2370	if (s->mb_intra) {
2371	if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2372	int progressive_score, interlaced_score;
2373
2374	s->interlaced_dct = 0;
2375	progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2376	s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2377	NULL, wrap_y, 8) - 400;
2378
2379	if (progressive_score > 0) {
2380	interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2381	NULL, wrap_y * 2, 8) +
2382	s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2383	NULL, wrap_y * 2, 8);
2384	if (progressive_score > interlaced_score) {
2385	s->interlaced_dct = 1;
2386
2387	dct_offset = wrap_y;
2388	uv_dct_offset = wrap_c;
2389	wrap_y <<= 1;
2390	if (s->chroma_format == CHROMA_422 ||
2391	s->chroma_format == CHROMA_444)
2392	wrap_c <<= 1;
2393	}
2394	}
2395	}
2396
2397	s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2398	s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2399	s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2400	s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2401
2402	if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2403	skip_dct[4] = 1;
2404	skip_dct[5] = 1;
2405	} else {
2406	s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2407	s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2408	if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2409	s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2410	s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2411	} else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2412	s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2413	s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2414	s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2415	s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2416	s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2417	s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2418	}
2419	}
2420	} else {
2421	op_pixels_func (*op_pix)[4];
2422	qpel_mc_func (*op_qpix)[16];
2423	uint8_t *dest_y, *dest_cb, *dest_cr;
2424
2425	dest_y = s->dest[0];
2426	dest_cb = s->dest[1];
2427	dest_cr = s->dest[2];
2428
2429	if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2430	op_pix = s->hdsp.put_pixels_tab;
2431	op_qpix = s->qdsp.put_qpel_pixels_tab;
2432	} else {
2433	op_pix = s->hdsp.put_no_rnd_pixels_tab;
2434	op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2435	}
2436
2437	if (s->mv_dir & MV_DIR_FORWARD) {
2438	ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2439	s->last_picture.f->data,
2440	op_pix, op_qpix);
2441	op_pix = s->hdsp.avg_pixels_tab;
2442	op_qpix = s->qdsp.avg_qpel_pixels_tab;
2443	}
2444	if (s->mv_dir & MV_DIR_BACKWARD) {
2445	ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2446	s->next_picture.f->data,
2447	op_pix, op_qpix);
2448	}
2449
2450	if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2451	int progressive_score, interlaced_score;
2452
2453	s->interlaced_dct = 0;
2454	progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2455	s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2456	ptr_y + wrap_y * 8,
2457	wrap_y, 8) - 400;
2458
2459	if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2460	progressive_score -= 400;
2461
2462	if (progressive_score > 0) {
2463	interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2464	wrap_y * 2, 8) +
2465	s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2466	ptr_y + wrap_y,
2467	wrap_y * 2, 8);
2468
2469	if (progressive_score > interlaced_score) {
2470	s->interlaced_dct = 1;
2471
2472	dct_offset = wrap_y;
2473	uv_dct_offset = wrap_c;
2474	wrap_y <<= 1;
2475	if (s->chroma_format == CHROMA_422)
2476	wrap_c <<= 1;
2477	}
2478	}
2479	}
2480
2481	s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2482	s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2483	s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2484	dest_y + dct_offset, wrap_y);
2485	s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2486	dest_y + dct_offset + 8, wrap_y);
2487
2488	if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2489	skip_dct[4] = 1;
2490	skip_dct[5] = 1;
2491	} else {
2492	s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2493	s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2494	if (!s->chroma_y_shift) { /* 422 */
2495	s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2496	dest_cb + uv_dct_offset, wrap_c);
2497	s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2498	dest_cr + uv_dct_offset, wrap_c);
2499	}
2500	}
2501	/* pre quantization */
2502	if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2503	2 * s->qscale * s->qscale) {
2504	// FIXME optimize
2505	if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2506	skip_dct[0] = 1;
2507	if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2508	skip_dct[1] = 1;
2509	if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2510	wrap_y, 8) < 20 * s->qscale)
2511	skip_dct[2] = 1;
2512	if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2513	wrap_y, 8) < 20 * s->qscale)
2514	skip_dct[3] = 1;
2515	if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2516	skip_dct[4] = 1;
2517	if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2518	skip_dct[5] = 1;
2519	if (!s->chroma_y_shift) { /* 422 */
2520	if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2521	dest_cb + uv_dct_offset,
2522	wrap_c, 8) < 20 * s->qscale)
2523	skip_dct[6] = 1;
2524	if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2525	dest_cr + uv_dct_offset,
2526	wrap_c, 8) < 20 * s->qscale)
2527	skip_dct[7] = 1;
2528	}
2529	}
2530	}
2531
2532	if (s->quantizer_noise_shaping) {
2533	if (!skip_dct[0])
2534	get_visual_weight(weight[0], ptr_y , wrap_y);
2535	if (!skip_dct[1])
2536	get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2537	if (!skip_dct[2])
2538	get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2539	if (!skip_dct[3])
2540	get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2541	if (!skip_dct[4])
2542	get_visual_weight(weight[4], ptr_cb , wrap_c);
2543	if (!skip_dct[5])
2544	get_visual_weight(weight[5], ptr_cr , wrap_c);
2545	if (!s->chroma_y_shift) { /* 422 */
2546	if (!skip_dct[6])
2547	get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2548	wrap_c);
2549	if (!skip_dct[7])
2550	get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2551	wrap_c);
2552	}
2553	memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2554	}
2555
2556	/* DCT & quantize */
2557	av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2558	{
2559	for (i = 0; i < mb_block_count; i++) {
2560	if (!skip_dct[i]) {
2561	int overflow;
2562	s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2563	// FIXME we could decide to change to quantizer instead of
2564	// clipping
2565	// JS: I don't think that would be a good idea it could lower
2566	// quality instead of improve it. Just INTRADC clipping
2567	// deserves changes in quantizer
2568	if (overflow)
2569	clip_coeffs(s, s->block[i], s->block_last_index[i]);
2570	} else
2571	s->block_last_index[i] = -1;
2572	}
2573	if (s->quantizer_noise_shaping) {
2574	for (i = 0; i < mb_block_count; i++) {
2575	if (!skip_dct[i]) {
2576	s->block_last_index[i] =
2577	dct_quantize_refine(s, s->block[i], weight[i],
2578	orig[i], i, s->qscale);
2579	}
2580	}
2581	}
2582
2583	if (s->luma_elim_threshold && !s->mb_intra)
2584	for (i = 0; i < 4; i++)
2585	dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2586	if (s->chroma_elim_threshold && !s->mb_intra)
2587	for (i = 4; i < mb_block_count; i++)
2588	dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2589
2590	if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2591	for (i = 0; i < mb_block_count; i++) {
2592	if (s->block_last_index[i] == -1)
2593	s->coded_score[i] = INT_MAX / 256;
2594	}
2595	}
2596	}
2597
2598	if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2599	s->block_last_index[4] =
2600	s->block_last_index[5] = 0;
2601	s->block[4][0] =
2602	s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2603	if (!s->chroma_y_shift) { /* 422 / 444 */
2604	for (i=6; i<12; i++) {
2605	s->block_last_index[i] = 0;
2606	s->block[i][0] = s->block[4][0];
2607	}
2608	}
2609	}
2610
2611	// non c quantize code returns incorrect block_last_index FIXME
2612	if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2613	for (i = 0; i < mb_block_count; i++) {
2614	int j;
2615	if (s->block_last_index[i] > 0) {
2616	for (j = 63; j > 0; j--) {
2617	if (s->block[i][s->intra_scantable.permutated[j]])
2618	break;
2619	}
2620	s->block_last_index[i] = j;
2621	}
2622	}
2623	}
2624
2625	/* huffman encode */
2626	switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2627	case AV_CODEC_ID_MPEG1VIDEO:
2628	case AV_CODEC_ID_MPEG2VIDEO:
2629	if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2630	ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2631	break;
2632	case AV_CODEC_ID_MPEG4:
2633	if (CONFIG_MPEG4_ENCODER)
2634	ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2635	break;
2636	case AV_CODEC_ID_MSMPEG4V2:
2637	case AV_CODEC_ID_MSMPEG4V3:
2638	case AV_CODEC_ID_WMV1:
2639	if (CONFIG_MSMPEG4_ENCODER)
2640	ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2641	break;
2642	case AV_CODEC_ID_WMV2:
2643	if (CONFIG_WMV2_ENCODER)
2644	ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2645	break;
2646	case AV_CODEC_ID_H261:
2647	if (CONFIG_H261_ENCODER)
2648	ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2649	break;
2650	case AV_CODEC_ID_H263:
2651	case AV_CODEC_ID_H263P:
2652	case AV_CODEC_ID_FLV1:
2653	case AV_CODEC_ID_RV10:
2654	case AV_CODEC_ID_RV20:
2655	if (CONFIG_H263_ENCODER)
2656	ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2657	break;
2658	case AV_CODEC_ID_MJPEG:
2659	case AV_CODEC_ID_AMV:
2660	if (CONFIG_MJPEG_ENCODER)
2661	ff_mjpeg_encode_mb(s, s->block);
2662	break;
2663	default:
2664	av_assert1(0);
2665	}
2666	}
2667
2668	static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2669	{
2670	if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2671	else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2672	else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2673	}
2674
2675	static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2676	int i;
2677
2678	memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2679
2680	/* MPEG-1 */
2681	d->mb_skip_run= s->mb_skip_run;
2682	for(i=0; i<3; i++)
2683	d->last_dc[i] = s->last_dc[i];
2684
2685	/* statistics */
2686	d->mv_bits= s->mv_bits;
2687	d->i_tex_bits= s->i_tex_bits;
2688	d->p_tex_bits= s->p_tex_bits;
2689	d->i_count= s->i_count;
2690	d->f_count= s->f_count;
2691	d->b_count= s->b_count;
2692	d->skip_count= s->skip_count;
2693	d->misc_bits= s->misc_bits;
2694	d->last_bits= 0;
2695
2696	d->mb_skipped= 0;
2697	d->qscale= s->qscale;
2698	d->dquant= s->dquant;
2699
2700	d->esc3_level_length= s->esc3_level_length;
2701	}
2702
2703	static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2704	int i;
2705
2706	memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2707	memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2708
2709	/* MPEG-1 */
2710	d->mb_skip_run= s->mb_skip_run;
2711	for(i=0; i<3; i++)
2712	d->last_dc[i] = s->last_dc[i];
2713
2714	/* statistics */
2715	d->mv_bits= s->mv_bits;
2716	d->i_tex_bits= s->i_tex_bits;
2717	d->p_tex_bits= s->p_tex_bits;
2718	d->i_count= s->i_count;
2719	d->f_count= s->f_count;
2720	d->b_count= s->b_count;
2721	d->skip_count= s->skip_count;
2722	d->misc_bits= s->misc_bits;
2723
2724	d->mb_intra= s->mb_intra;
2725	d->mb_skipped= s->mb_skipped;
2726	d->mv_type= s->mv_type;
2727	d->mv_dir= s->mv_dir;
2728	d->pb= s->pb;
2729	if(s->data_partitioning){
2730	d->pb2= s->pb2;
2731	d->tex_pb= s->tex_pb;
2732	}
2733	d->block= s->block;
2734	for(i=0; i<8; i++)
2735	d->block_last_index[i]= s->block_last_index[i];
2736	d->interlaced_dct= s->interlaced_dct;
2737	d->qscale= s->qscale;
2738
2739	d->esc3_level_length= s->esc3_level_length;
2740	}
2741
2742	static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2743	PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2744	int *dmin, int *next_block, int motion_x, int motion_y)
2745	{
2746	int score;
2747	uint8_t *dest_backup[3];
2748
2749	copy_context_before_encode(s, backup, type);
2750
2751	s->block= s->blocks[*next_block];
2752	s->pb= pb[*next_block];
2753	if(s->data_partitioning){
2754	s->pb2 = pb2 [*next_block];
2755	s->tex_pb= tex_pb[*next_block];
2756	}
2757
2758	if(*next_block){
2759	memcpy(dest_backup, s->dest, sizeof(s->dest));
2760	s->dest[0] = s->sc.rd_scratchpad;
2761	s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2762	s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2763	av_assert0(s->linesize >= 32); //FIXME
2764	}
2765
2766	encode_mb(s, motion_x, motion_y);
2767
2768	score= put_bits_count(&s->pb);
2769	if(s->data_partitioning){
2770	score+= put_bits_count(&s->pb2);
2771	score+= put_bits_count(&s->tex_pb);
2772	}
2773
2774	if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2775	ff_mpv_decode_mb(s, s->block);
2776
2777	score *= s->lambda2;
2778	score += sse_mb(s) << FF_LAMBDA_SHIFT;
2779	}
2780
2781	if(*next_block){
2782	memcpy(s->dest, dest_backup, sizeof(s->dest));
2783	}
2784
2785	if(score<*dmin){
2786	*dmin= score;
2787	*next_block^=1;
2788
2789	copy_context_after_encode(best, s, type);
2790	}
2791	}
2792
2793	static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2794	uint32_t *sq = ff_square_tab + 256;
2795	int acc=0;
2796	int x,y;
2797
2798	if(w==16 && h==16)
2799	return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2800	else if(w==8 && h==8)
2801	return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2802
2803	for(y=0; y<h; y++){
2804	for(x=0; x<w; x++){
2805	acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2806	}
2807	}
2808
2809	av_assert2(acc>=0);
2810
2811	return acc;
2812	}
2813
2814	static int sse_mb(MpegEncContext *s){
2815	int w= 16;
2816	int h= 16;
2817
2818	if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2819	if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2820
2821	if(w==16 && h==16)
2822	if(s->avctx->mb_cmp == FF_CMP_NSSE){
2823	return s->mecc.nsse[0](s, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16, s->dest[0], s->linesize, 16) +
2824	s->mecc.nsse[1](s, s->new_picture.f->data[1] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[1], s->uvlinesize, 8) +
2825	s->mecc.nsse[1](s, s->new_picture.f->data[2] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[2], s->uvlinesize, 8);
2826	}else{
2827	return s->mecc.sse[0](NULL, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16, s->dest[0], s->linesize, 16) +
2828	s->mecc.sse[1](NULL, s->new_picture.f->data[1] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[1], s->uvlinesize, 8) +
2829	s->mecc.sse[1](NULL, s->new_picture.f->data[2] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[2], s->uvlinesize, 8);
2830	}
2831	else
2832	return sse(s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
2833	+sse(s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
2834	+sse(s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
2835	}
2836
2837	static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2838	MpegEncContext *s= *(void**)arg;
2839
2840
2841	s->me.pre_pass=1;
2842	s->me.dia_size= s->avctx->pre_dia_size;
2843	s->first_slice_line=1;
2844	for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2845	for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2846	ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2847	}
2848	s->first_slice_line=0;
2849	}
2850
2851	s->me.pre_pass=0;
2852
2853	return 0;
2854	}
2855
2856	static int estimate_motion_thread(AVCodecContext *c, void *arg){
2857	MpegEncContext *s= *(void**)arg;
2858
2859	ff_check_alignment();
2860
2861	s->me.dia_size= s->avctx->dia_size;
2862	s->first_slice_line=1;
2863	for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2864	s->mb_x=0; //for block init below
2865	ff_init_block_index(s);
2866	for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2867	s->block_index[0]+=2;
2868	s->block_index[1]+=2;
2869	s->block_index[2]+=2;
2870	s->block_index[3]+=2;
2871
2872	/* compute motion vector & mb_type and store in context */
2873	if(s->pict_type==AV_PICTURE_TYPE_B)
2874	ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2875	else
2876	ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2877	}
2878	s->first_slice_line=0;
2879	}
2880	return 0;
2881	}
2882
2883	static int mb_var_thread(AVCodecContext *c, void *arg){
2884	MpegEncContext *s= *(void**)arg;
2885	int mb_x, mb_y;
2886
2887	ff_check_alignment();
2888
2889	for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2890	for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2891	int xx = mb_x * 16;
2892	int yy = mb_y * 16;
2893	uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2894	int varc;
2895	int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2896
2897	varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2898	(((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2899
2900	s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2901	s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2902	s->me.mb_var_sum_temp += varc;
2903	}
2904	}
2905	return 0;
2906	}
2907
2908	static void write_slice_end(MpegEncContext *s){
2909	if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2910	if(s->partitioned_frame){
2911	ff_mpeg4_merge_partitions(s);
2912	}
2913
2914	ff_mpeg4_stuffing(&s->pb);
2915	}else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2916	ff_mjpeg_encode_stuffing(s);
2917	}
2918
2919	avpriv_align_put_bits(&s->pb);
2920	flush_put_bits(&s->pb);
2921
2922	if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2923	s->misc_bits+= get_bits_diff(s);
2924	}
2925
2926	static void write_mb_info(MpegEncContext *s)
2927	{
2928	uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2929	int offset = put_bits_count(&s->pb);
2930	int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2931	int gobn = s->mb_y / s->gob_index;
2932	int pred_x, pred_y;
2933	if (CONFIG_H263_ENCODER)
2934	ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2935	bytestream_put_le32(&ptr, offset);
2936	bytestream_put_byte(&ptr, s->qscale);
2937	bytestream_put_byte(&ptr, gobn);
2938	bytestream_put_le16(&ptr, mba);
2939	bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2940	bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2941	/* 4MV not implemented */
2942	bytestream_put_byte(&ptr, 0); /* hmv2 */
2943	bytestream_put_byte(&ptr, 0); /* vmv2 */
2944	}
2945
2946	static void update_mb_info(MpegEncContext *s, int startcode)
2947	{
2948	if (!s->mb_info)
2949	return;
2950	if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2951	s->mb_info_size += 12;
2952	s->prev_mb_info = s->last_mb_info;
2953	}
2954	if (startcode) {
2955	s->prev_mb_info = put_bits_count(&s->pb)/8;
2956	/* This might have incremented mb_info_size above, and we return without
2957	* actually writing any info into that slot yet. But in that case,
2958	* this will be called again at the start of the after writing the
2959	* start code, actually writing the mb info. */
2960	return;
2961	}
2962
2963	s->last_mb_info = put_bits_count(&s->pb)/8;
2964	if (!s->mb_info_size)
2965	s->mb_info_size += 12;
2966	write_mb_info(s);
2967	}
2968
2969	int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2970	{
2971	if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2972	&& s->slice_context_count == 1
2973	&& s->pb.buf == s->avctx->internal->byte_buffer) {
2974	int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2975	int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2976
2977	uint8_t *new_buffer = NULL;
2978	int new_buffer_size = 0;
2979
2980	if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2981	av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2982	return AVERROR(ENOMEM);
2983	}
2984
2985	emms_c();
2986
2987	av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2988	s->avctx->internal->byte_buffer_size + size_increase);
2989	if (!new_buffer)
2990	return AVERROR(ENOMEM);
2991
2992	memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2993	av_free(s->avctx->internal->byte_buffer);
2994	s->avctx->internal->byte_buffer = new_buffer;
2995	s->avctx->internal->byte_buffer_size = new_buffer_size;
2996	rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2997	s->ptr_lastgob = s->pb.buf + lastgob_pos;
2998	s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2999	}
3000	if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
3001	return AVERROR(EINVAL);
3002	return 0;
3003	}
3004
3005	static int encode_thread(AVCodecContext *c, void *arg){
3006	MpegEncContext *s= *(void**)arg;
3007	int mb_x, mb_y;
3008	int chr_h= 16>>s->chroma_y_shift;
3009	int i, j;
3010	MpegEncContext best_s = { 0 }, backup_s;
3011	uint8_t bit_buf[2][MAX_MB_BYTES];
3012	uint8_t bit_buf2[2][MAX_MB_BYTES];
3013	uint8_t bit_buf_tex[2][MAX_MB_BYTES];
3014	PutBitContext pb[2], pb2[2], tex_pb[2];
3015
3016	ff_check_alignment();
3017
3018	for(i=0; i<2; i++){
3019	init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
3020	init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
3021	init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
3022	}
3023
3024	s->last_bits= put_bits_count(&s->pb);
3025	s->mv_bits=0;
3026	s->misc_bits=0;
3027	s->i_tex_bits=0;
3028	s->p_tex_bits=0;
3029	s->i_count=0;
3030	s->f_count=0;
3031	s->b_count=0;
3032	s->skip_count=0;
3033
3034	for(i=0; i<3; i++){
3035	/* init last dc values */
3036	/* note: quant matrix value (8) is implied here */
3037	s->last_dc[i] = 128 << s->intra_dc_precision;
3038
3039	s->current_picture.encoding_error[i] = 0;
3040	}
3041	if(s->codec_id==AV_CODEC_ID_AMV){
3042	s->last_dc[0] = 128*8/13;
3043	s->last_dc[1] = 128*8/14;
3044	s->last_dc[2] = 128*8/14;
3045	}
3046	s->mb_skip_run = 0;
3047	memset(s->last_mv, 0, sizeof(s->last_mv));
3048
3049	s->last_mv_dir = 0;
3050
3051	switch(s->codec_id){
3052	case AV_CODEC_ID_H263:
3053	case AV_CODEC_ID_H263P:
3054	case AV_CODEC_ID_FLV1:
3055	if (CONFIG_H263_ENCODER)
3056	s->gob_index = H263_GOB_HEIGHT(s->height);
3057	break;
3058	case AV_CODEC_ID_MPEG4:
3059	if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3060	ff_mpeg4_init_partitions(s);
3061	break;
3062	}
3063
3064	s->resync_mb_x=0;
3065	s->resync_mb_y=0;
3066	s->first_slice_line = 1;
3067	s->ptr_lastgob = s->pb.buf;
3068	for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3069	s->mb_x=0;
3070	s->mb_y= mb_y;
3071
3072	ff_set_qscale(s, s->qscale);
3073	ff_init_block_index(s);
3074
3075	for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3076	int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3077	int mb_type= s->mb_type[xy];
3078	// int d;
3079	int dmin= INT_MAX;
3080	int dir;
3081	int size_increase = s->avctx->internal->byte_buffer_size/4
3082	+ s->mb_width*MAX_MB_BYTES;
3083
3084	ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3085	if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3086	av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3087	return -1;
3088	}
3089	if(s->data_partitioning){
3090	if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
3091	|| s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3092	av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3093	return -1;
3094	}
3095	}
3096
3097	s->mb_x = mb_x;
3098	s->mb_y = mb_y; // moved into loop, can get changed by H.261
3099	ff_update_block_index(s);
3100
3101	if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3102	ff_h261_reorder_mb_index(s);
3103	xy= s->mb_y*s->mb_stride + s->mb_x;
3104	mb_type= s->mb_type[xy];
3105	}
3106
3107	/* write gob / video packet header */
3108	if(s->rtp_mode){
3109	int current_packet_size, is_gob_start;
3110
3111	current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3112
3113	is_gob_start = s->rtp_payload_size &&
3114	current_packet_size >= s->rtp_payload_size &&
3115	mb_y + mb_x > 0;
3116
3117	if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3118
3119	switch(s->codec_id){
3120	case AV_CODEC_ID_H263:
3121	case AV_CODEC_ID_H263P:
3122	if(!s->h263_slice_structured)
3123	if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3124	break;
3125	case AV_CODEC_ID_MPEG2VIDEO:
3126	if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3127	case AV_CODEC_ID_MPEG1VIDEO:
3128	if(s->mb_skip_run) is_gob_start=0;
3129	break;
3130	case AV_CODEC_ID_MJPEG:
3131	if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3132	break;
3133	}
3134
3135	if(is_gob_start){
3136	if(s->start_mb_y != mb_y || mb_x!=0){
3137	write_slice_end(s);
3138
3139	if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3140	ff_mpeg4_init_partitions(s);
3141	}
3142	}
3143
3144	av_assert2((put_bits_count(&s->pb)&7) == 0);
3145	current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3146
3147	if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3148	int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3149	int d = 100 / s->error_rate;
3150	if(r % d == 0){
3151	current_packet_size=0;
3152	s->pb.buf_ptr= s->ptr_lastgob;
3153	assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3154	}
3155	}
3156
3157	#if FF_API_RTP_CALLBACK
3158	FF_DISABLE_DEPRECATION_WARNINGS
3159	if (s->avctx->rtp_callback){
3160	int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3161	s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3162	}
3163	FF_ENABLE_DEPRECATION_WARNINGS
3164	#endif
3165	update_mb_info(s, 1);
3166
3167	switch(s->codec_id){
3168	case AV_CODEC_ID_MPEG4:
3169	if (CONFIG_MPEG4_ENCODER) {
3170	ff_mpeg4_encode_video_packet_header(s);
3171	ff_mpeg4_clean_buffers(s);
3172	}
3173	break;
3174	case AV_CODEC_ID_MPEG1VIDEO:
3175	case AV_CODEC_ID_MPEG2VIDEO:
3176	if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3177	ff_mpeg1_encode_slice_header(s);
3178	ff_mpeg1_clean_buffers(s);
3179	}
3180	break;
3181	case AV_CODEC_ID_H263:
3182	case AV_CODEC_ID_H263P:
3183	if (CONFIG_H263_ENCODER)
3184	ff_h263_encode_gob_header(s, mb_y);
3185	break;
3186	}
3187
3188	if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3189	int bits= put_bits_count(&s->pb);
3190	s->misc_bits+= bits - s->last_bits;
3191	s->last_bits= bits;
3192	}
3193
3194	s->ptr_lastgob += current_packet_size;
3195	s->first_slice_line=1;
3196	s->resync_mb_x=mb_x;
3197	s->resync_mb_y=mb_y;
3198	}
3199	}
3200
3201	if( (s->resync_mb_x == s->mb_x)
3202	&& s->resync_mb_y+1 == s->mb_y){
3203	s->first_slice_line=0;
3204	}
3205
3206	s->mb_skipped=0;
3207	s->dquant=0; //only for QP_RD
3208
3209	update_mb_info(s, 0);
3210
3211	if (mb_type & (mb_type-1) || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) { // more than 1 MB type possible or FF_MPV_FLAG_QP_RD
3212	int next_block=0;
3213	int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3214
3215	copy_context_before_encode(&backup_s, s, -1);
3216	backup_s.pb= s->pb;
3217	best_s.data_partitioning= s->data_partitioning;
3218	best_s.partitioned_frame= s->partitioned_frame;
3219	if(s->data_partitioning){
3220	backup_s.pb2= s->pb2;
3221	backup_s.tex_pb= s->tex_pb;
3222	}
3223
3224	if(mb_type&CANDIDATE_MB_TYPE_INTER){
3225	s->mv_dir = MV_DIR_FORWARD;
3226	s->mv_type = MV_TYPE_16X16;
3227	s->mb_intra= 0;
3228	s->mv[0][0][0] = s->p_mv_table[xy][0];
3229	s->mv[0][0][1] = s->p_mv_table[xy][1];
3230	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3231	&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3232	}
3233	if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3234	s->mv_dir = MV_DIR_FORWARD;
3235	s->mv_type = MV_TYPE_FIELD;
3236	s->mb_intra= 0;
3237	for(i=0; i<2; i++){
3238	j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3239	s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3240	s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3241	}
3242	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3243	&dmin, &next_block, 0, 0);
3244	}
3245	if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3246	s->mv_dir = MV_DIR_FORWARD;
3247	s->mv_type = MV_TYPE_16X16;
3248	s->mb_intra= 0;
3249	s->mv[0][0][0] = 0;
3250	s->mv[0][0][1] = 0;
3251	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3252	&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3253	}
3254	if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3255	s->mv_dir = MV_DIR_FORWARD;
3256	s->mv_type = MV_TYPE_8X8;
3257	s->mb_intra= 0;
3258	for(i=0; i<4; i++){
3259	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3260	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3261	}
3262	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3263	&dmin, &next_block, 0, 0);
3264	}
3265	if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3266	s->mv_dir = MV_DIR_FORWARD;
3267	s->mv_type = MV_TYPE_16X16;
3268	s->mb_intra= 0;
3269	s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3270	s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3271	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3272	&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3273	}
3274	if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3275	s->mv_dir = MV_DIR_BACKWARD;
3276	s->mv_type = MV_TYPE_16X16;
3277	s->mb_intra= 0;
3278	s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3279	s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3280	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3281	&dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3282	}
3283	if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3284	s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3285	s->mv_type = MV_TYPE_16X16;
3286	s->mb_intra= 0;
3287	s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3288	s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3289	s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3290	s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3291	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3292	&dmin, &next_block, 0, 0);
3293	}
3294	if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3295	s->mv_dir = MV_DIR_FORWARD;
3296	s->mv_type = MV_TYPE_FIELD;
3297	s->mb_intra= 0;
3298	for(i=0; i<2; i++){
3299	j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3300	s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3301	s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3302	}
3303	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3304	&dmin, &next_block, 0, 0);
3305	}
3306	if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3307	s->mv_dir = MV_DIR_BACKWARD;
3308	s->mv_type = MV_TYPE_FIELD;
3309	s->mb_intra= 0;
3310	for(i=0; i<2; i++){
3311	j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3312	s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3313	s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3314	}
3315	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3316	&dmin, &next_block, 0, 0);
3317	}
3318	if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3319	s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3320	s->mv_type = MV_TYPE_FIELD;
3321	s->mb_intra= 0;
3322	for(dir=0; dir<2; dir++){
3323	for(i=0; i<2; i++){
3324	j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3325	s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3326	s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3327	}
3328	}
3329	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3330	&dmin, &next_block, 0, 0);
3331	}
3332	if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3333	s->mv_dir = 0;
3334	s->mv_type = MV_TYPE_16X16;
3335	s->mb_intra= 1;
3336	s->mv[0][0][0] = 0;
3337	s->mv[0][0][1] = 0;
3338	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3339	&dmin, &next_block, 0, 0);
3340	if(s->h263_pred || s->h263_aic){
3341	if(best_s.mb_intra)
3342	s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3343	else
3344	ff_clean_intra_table_entries(s); //old mode?
3345	}
3346	}
3347
3348	if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3349	if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3350	const int last_qp= backup_s.qscale;
3351	int qpi, qp, dc[6];
3352	int16_t ac[6][16];
3353	const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3354	static const int dquant_tab[4]={-1,1,-2,2};
3355	int storecoefs = s->mb_intra && s->dc_val[0];
3356
3357	av_assert2(backup_s.dquant == 0);
3358
3359	//FIXME intra
3360	s->mv_dir= best_s.mv_dir;
3361	s->mv_type = MV_TYPE_16X16;
3362	s->mb_intra= best_s.mb_intra;
3363	s->mv[0][0][0] = best_s.mv[0][0][0];
3364	s->mv[0][0][1] = best_s.mv[0][0][1];
3365	s->mv[1][0][0] = best_s.mv[1][0][0];
3366	s->mv[1][0][1] = best_s.mv[1][0][1];
3367
3368	qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3369	for(; qpi<4; qpi++){
3370	int dquant= dquant_tab[qpi];
3371	qp= last_qp + dquant;
3372	if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3373	continue;
3374	backup_s.dquant= dquant;
3375	if(storecoefs){
3376	for(i=0; i<6; i++){
3377	dc[i]= s->dc_val[0][ s->block_index[i] ];
3378	memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3379	}
3380	}
3381
3382	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3383	&dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3384	if(best_s.qscale != qp){
3385	if(storecoefs){
3386	for(i=0; i<6; i++){
3387	s->dc_val[0][ s->block_index[i] ]= dc[i];
3388	memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3389	}
3390	}
3391	}
3392	}
3393	}
3394	}
3395	if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3396	int mx= s->b_direct_mv_table[xy][0];
3397	int my= s->b_direct_mv_table[xy][1];
3398
3399	backup_s.dquant = 0;
3400	s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3401	s->mb_intra= 0;
3402	ff_mpeg4_set_direct_mv(s, mx, my);
3403	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3404	&dmin, &next_block, mx, my);
3405	}
3406	if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3407	backup_s.dquant = 0;
3408	s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3409	s->mb_intra= 0;
3410	ff_mpeg4_set_direct_mv(s, 0, 0);
3411	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3412	&dmin, &next_block, 0, 0);
3413	}
3414	if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3415	int coded=0;
3416	for(i=0; i<6; i++)
3417	coded |= s->block_last_index[i];
3418	if(coded){
3419	int mx,my;
3420	memcpy(s->mv, best_s.mv, sizeof(s->mv));
3421	if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3422	mx=my=0; //FIXME find the one we actually used
3423	ff_mpeg4_set_direct_mv(s, mx, my);
3424	}else if(best_s.mv_dir&MV_DIR_BACKWARD){
3425	mx= s->mv[1][0][0];
3426	my= s->mv[1][0][1];
3427	}else{
3428	mx= s->mv[0][0][0];
3429	my= s->mv[0][0][1];
3430	}
3431
3432	s->mv_dir= best_s.mv_dir;
3433	s->mv_type = best_s.mv_type;
3434	s->mb_intra= 0;
3435	/* s->mv[0][0][0] = best_s.mv[0][0][0];
3436	s->mv[0][0][1] = best_s.mv[0][0][1];
3437	s->mv[1][0][0] = best_s.mv[1][0][0];
3438	s->mv[1][0][1] = best_s.mv[1][0][1];*/
3439	backup_s.dquant= 0;
3440	s->skipdct=1;
3441	encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3442	&dmin, &next_block, mx, my);
3443	s->skipdct=0;
3444	}
3445	}
3446
3447	s->current_picture.qscale_table[xy] = best_s.qscale;
3448
3449	copy_context_after_encode(s, &best_s, -1);
3450
3451	pb_bits_count= put_bits_count(&s->pb);
3452	flush_put_bits(&s->pb);
3453	avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3454	s->pb= backup_s.pb;
3455
3456	if(s->data_partitioning){
3457	pb2_bits_count= put_bits_count(&s->pb2);
3458	flush_put_bits(&s->pb2);
3459	avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3460	s->pb2= backup_s.pb2;
3461
3462	tex_pb_bits_count= put_bits_count(&s->tex_pb);
3463	flush_put_bits(&s->tex_pb);
3464	avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3465	s->tex_pb= backup_s.tex_pb;
3466	}
3467	s->last_bits= put_bits_count(&s->pb);
3468
3469	if (CONFIG_H263_ENCODER &&
3470	s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3471	ff_h263_update_motion_val(s);
3472
3473	if(next_block==0){ //FIXME 16 vs linesize16
3474	s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3475	s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3476	s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3477	}
3478
3479	if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3480	ff_mpv_decode_mb(s, s->block);
3481	} else {
3482	int motion_x = 0, motion_y = 0;
3483	s->mv_type=MV_TYPE_16X16;
3484	// only one MB-Type possible
3485
3486	switch(mb_type){
3487	case CANDIDATE_MB_TYPE_INTRA:
3488	s->mv_dir = 0;
3489	s->mb_intra= 1;
3490	motion_x= s->mv[0][0][0] = 0;
3491	motion_y= s->mv[0][0][1] = 0;
3492	break;
3493	case CANDIDATE_MB_TYPE_INTER:
3494	s->mv_dir = MV_DIR_FORWARD;
3495	s->mb_intra= 0;
3496	motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3497	motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3498	break;
3499	case CANDIDATE_MB_TYPE_INTER_I:
3500	s->mv_dir = MV_DIR_FORWARD;
3501	s->mv_type = MV_TYPE_FIELD;
3502	s->mb_intra= 0;
3503	for(i=0; i<2; i++){
3504	j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3505	s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3506	s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3507	}
3508	break;
3509	case CANDIDATE_MB_TYPE_INTER4V:
3510	s->mv_dir = MV_DIR_FORWARD;
3511	s->mv_type = MV_TYPE_8X8;
3512	s->mb_intra= 0;
3513	for(i=0; i<4; i++){
3514	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3515	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3516	}
3517	break;
3518	case CANDIDATE_MB_TYPE_DIRECT:
3519	if (CONFIG_MPEG4_ENCODER) {
3520	s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3521	s->mb_intra= 0;
3522	motion_x=s->b_direct_mv_table[xy][0];
3523	motion_y=s->b_direct_mv_table[xy][1];
3524	ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3525	}
3526	break;
3527	case CANDIDATE_MB_TYPE_DIRECT0:
3528	if (CONFIG_MPEG4_ENCODER) {
3529	s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3530	s->mb_intra= 0;
3531	ff_mpeg4_set_direct_mv(s, 0, 0);
3532	}
3533	break;
3534	case CANDIDATE_MB_TYPE_BIDIR:
3535	s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3536	s->mb_intra= 0;
3537	s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3538	s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3539	s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3540	s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3541	break;
3542	case CANDIDATE_MB_TYPE_BACKWARD:
3543	s->mv_dir = MV_DIR_BACKWARD;
3544	s->mb_intra= 0;
3545	motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3546	motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3547	break;
3548	case CANDIDATE_MB_TYPE_FORWARD:
3549	s->mv_dir = MV_DIR_FORWARD;
3550	s->mb_intra= 0;
3551	motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3552	motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3553	break;
3554	case CANDIDATE_MB_TYPE_FORWARD_I:
3555	s->mv_dir = MV_DIR_FORWARD;
3556	s->mv_type = MV_TYPE_FIELD;
3557	s->mb_intra= 0;
3558	for(i=0; i<2; i++){
3559	j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3560	s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3561	s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3562	}
3563	break;
3564	case CANDIDATE_MB_TYPE_BACKWARD_I:
3565	s->mv_dir = MV_DIR_BACKWARD;
3566	s->mv_type = MV_TYPE_FIELD;
3567	s->mb_intra= 0;
3568	for(i=0; i<2; i++){
3569	j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3570	s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3571	s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3572	}
3573	break;
3574	case CANDIDATE_MB_TYPE_BIDIR_I:
3575	s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3576	s->mv_type = MV_TYPE_FIELD;
3577	s->mb_intra= 0;
3578	for(dir=0; dir<2; dir++){
3579	for(i=0; i<2; i++){
3580	j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3581	s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3582	s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3583	}
3584	}
3585	break;
3586	default:
3587	av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3588	}
3589
3590	encode_mb(s, motion_x, motion_y);
3591
3592	// RAL: Update last macroblock type
3593	s->last_mv_dir = s->mv_dir;
3594
3595	if (CONFIG_H263_ENCODER &&
3596	s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3597	ff_h263_update_motion_val(s);
3598
3599	ff_mpv_decode_mb(s, s->block);
3600	}
3601
3602	/* clean the MV table in IPS frames for direct mode in B-frames */
3603	if(s->mb_intra /* && I,P,S_TYPE */){
3604	s->p_mv_table[xy][0]=0;
3605	s->p_mv_table[xy][1]=0;
3606	}
3607
3608	if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3609	int w= 16;
3610	int h= 16;
3611
3612	if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3613	if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3614
3615	s->current_picture.encoding_error[0] += sse(
3616	s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3617	s->dest[0], w, h, s->linesize);
3618	s->current_picture.encoding_error[1] += sse(
3619	s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3620	s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3621	s->current_picture.encoding_error[2] += sse(
3622	s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3623	s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3624	}
3625	if(s->loop_filter){
3626	if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3627	ff_h263_loop_filter(s);
3628	}
3629	ff_dlog(s->avctx, "MB %d %d bits\n",
3630	s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3631	}
3632	}
3633
3634	//not beautiful here but we must write it before flushing so it has to be here
3635	if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3636	ff_msmpeg4_encode_ext_header(s);
3637
3638	write_slice_end(s);
3639
3640	#if FF_API_RTP_CALLBACK
3641	FF_DISABLE_DEPRECATION_WARNINGS
3642	/* Send the last GOB if RTP */
3643	if (s->avctx->rtp_callback) {
3644	int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3645	int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3646	/* Call the RTP callback to send the last GOB */
3647	emms_c();
3648	s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3649	}
3650	FF_ENABLE_DEPRECATION_WARNINGS
3651	#endif
3652
3653	return 0;
3654	}
3655
3656	#define MERGE(field) dst->field += src->field; src->field=0
3657	static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3658	MERGE(me.scene_change_score);
3659	MERGE(me.mc_mb_var_sum_temp);
3660	MERGE(me.mb_var_sum_temp);
3661	}
3662
3663	static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3664	int i;
3665
3666	MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3667	MERGE(dct_count[1]);
3668	MERGE(mv_bits);
3669	MERGE(i_tex_bits);
3670	MERGE(p_tex_bits);
3671	MERGE(i_count);
3672	MERGE(f_count);
3673	MERGE(b_count);
3674	MERGE(skip_count);
3675	MERGE(misc_bits);
3676	MERGE(er.error_count);
3677	MERGE(padding_bug_score);
3678	MERGE(current_picture.encoding_error[0]);
3679	MERGE(current_picture.encoding_error[1]);
3680	MERGE(current_picture.encoding_error[2]);
3681
3682	if (dst->noise_reduction){
3683	for(i=0; i<64; i++){
3684	MERGE(dct_error_sum[0][i]);
3685	MERGE(dct_error_sum[1][i]);
3686	}
3687	}
3688
3689	assert(put_bits_count(&src->pb) % 8 ==0);
3690	assert(put_bits_count(&dst->pb) % 8 ==0);
3691	avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3692	flush_put_bits(&dst->pb);
3693	}
3694
3695	static int estimate_qp(MpegEncContext *s, int dry_run){
3696	if (s->next_lambda){
3697	s->current_picture_ptr->f->quality =
3698	s->current_picture.f->quality = s->next_lambda;
3699	if(!dry_run) s->next_lambda= 0;
3700	} else if (!s->fixed_qscale) {
3701	int quality;
3702	#if CONFIG_LIBXVID
3703	if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
3704	quality = ff_xvid_rate_estimate_qscale(s, dry_run);
3705	else
3706	#endif
3707	quality = ff_rate_estimate_qscale(s, dry_run);
3708	s->current_picture_ptr->f->quality =
3709	s->current_picture.f->quality = quality;
3710	if (s->current_picture.f->quality < 0)
3711	return -1;
3712	}
3713
3714	if(s->adaptive_quant){
3715	switch(s->codec_id){
3716	case AV_CODEC_ID_MPEG4:
3717	if (CONFIG_MPEG4_ENCODER)
3718	ff_clean_mpeg4_qscales(s);
3719	break;
3720	case AV_CODEC_ID_H263:
3721	case AV_CODEC_ID_H263P:
3722	case AV_CODEC_ID_FLV1:
3723	if (CONFIG_H263_ENCODER)
3724	ff_clean_h263_qscales(s);
3725	break;
3726	default:
3727	ff_init_qscale_tab(s);
3728	}
3729
3730	s->lambda= s->lambda_table[0];
3731	//FIXME broken
3732	}else
3733	s->lambda = s->current_picture.f->quality;
3734	update_qscale(s);
3735	return 0;
3736	}
3737
3738	/* must be called before writing the header */
3739	static void set_frame_distances(MpegEncContext * s){
3740	av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3741	s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3742
3743	if(s->pict_type==AV_PICTURE_TYPE_B){
3744	s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3745	assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3746	}else{
3747	s->pp_time= s->time - s->last_non_b_time;
3748	s->last_non_b_time= s->time;
3749	assert(s->picture_number==0 || s->pp_time > 0);
3750	}
3751	}
3752
3753	static int encode_picture(MpegEncContext *s, int picture_number)
3754	{
3755	int i, ret;
3756	int bits;
3757	int context_count = s->slice_context_count;
3758
3759	s->picture_number = picture_number;
3760
3761	/* Reset the average MB variance */
3762	s->me.mb_var_sum_temp =
3763	s->me.mc_mb_var_sum_temp = 0;
3764
3765	/* we need to initialize some time vars before we can encode B-frames */
3766	// RAL: Condition added for MPEG1VIDEO
3767	if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3768	set_frame_distances(s);
3769	if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3770	ff_set_mpeg4_time(s);
3771
3772	s->me.scene_change_score=0;
3773
3774	// s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3775
3776	if(s->pict_type==AV_PICTURE_TYPE_I){
3777	if(s->msmpeg4_version >= 3) s->no_rounding=1;
3778	else s->no_rounding=0;
3779	}else if(s->pict_type!=AV_PICTURE_TYPE_B){
3780	if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3781	s->no_rounding ^= 1;
3782	}
3783
3784	if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3785	if (estimate_qp(s,1) < 0)
3786	return -1;
3787	ff_get_2pass_fcode(s);
3788	} else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3789	if(s->pict_type==AV_PICTURE_TYPE_B)
3790	s->lambda= s->last_lambda_for[s->pict_type];
3791	else
3792	s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3793	update_qscale(s);
3794	}
3795
3796	if(s->codec_id != AV_CODEC_ID_AMV && s->codec_id != AV_CODEC_ID_MJPEG){
3797	if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3798	if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3799	s->q_chroma_intra_matrix = s->q_intra_matrix;
3800	s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3801	}
3802
3803	s->mb_intra=0; //for the rate distortion & bit compare functions
3804	for(i=1; i<context_count; i++){
3805	ret = ff_update_duplicate_context(s->thread_context[i], s);
3806	if (ret < 0)
3807	return ret;
3808	}
3809
3810	if(ff_init_me(s)<0)
3811	return -1;
3812
3813	/* Estimate motion for every MB */
3814	if(s->pict_type != AV_PICTURE_TYPE_I){
3815	s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3816	s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3817	if (s->pict_type != AV_PICTURE_TYPE_B) {
3818	if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3819	s->me_pre == 2) {
3820	s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3821	}
3822	}
3823
3824	s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3825	}else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3826	/* I-Frame */
3827	for(i=0; i<s->mb_stride*s->mb_height; i++)
3828	s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3829
3830	if(!s->fixed_qscale){
3831	/* finding spatial complexity for I-frame rate control */
3832	s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3833	}
3834	}
3835	for(i=1; i<context_count; i++){
3836	merge_context_after_me(s, s->thread_context[i]);
3837	}
3838	s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3839	s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3840	emms_c();
3841
3842	if (s->me.scene_change_score > s->scenechange_threshold &&
3843	s->pict_type == AV_PICTURE_TYPE_P) {
3844	s->pict_type= AV_PICTURE_TYPE_I;
3845	for(i=0; i<s->mb_stride*s->mb_height; i++)
3846	s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3847	if(s->msmpeg4_version >= 3)
3848	s->no_rounding=1;
3849	ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3850	s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3851	}
3852
3853	if(!s->umvplus){
3854	if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3855	s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3856
3857	if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3858	int a,b;
3859	a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3860	b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3861	s->f_code= FFMAX3(s->f_code, a, b);
3862	}
3863
3864	ff_fix_long_p_mvs(s);
3865	ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3866	if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3867	int j;
3868	for(i=0; i<2; i++){
3869	for(j=0; j<2; j++)
3870	ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3871	s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3872	}
3873	}
3874	}
3875
3876	if(s->pict_type==AV_PICTURE_TYPE_B){
3877	int a, b;
3878
3879	a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3880	b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3881	s->f_code = FFMAX(a, b);
3882
3883	a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3884	b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3885	s->b_code = FFMAX(a, b);
3886
3887	ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3888	ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3889	ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3890	ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3891	if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3892	int dir, j;
3893	for(dir=0; dir<2; dir++){
3894	for(i=0; i<2; i++){
3895	for(j=0; j<2; j++){
3896	int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3897	: (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3898	ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3899	s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3900	}
3901	}
3902	}
3903	}
3904	}
3905	}
3906
3907	if (estimate_qp(s, 0) < 0)
3908	return -1;
3909
3910	if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3911	s->pict_type == AV_PICTURE_TYPE_I &&
3912	!(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3913	s->qscale= 3; //reduce clipping problems
3914
3915	if (s->out_format == FMT_MJPEG) {
3916	const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3917	const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3918
3919	if (s->avctx->intra_matrix) {
3920	chroma_matrix =
3921	luma_matrix = s->avctx->intra_matrix;
3922	}
3923	if (s->avctx->chroma_intra_matrix)
3924	chroma_matrix = s->avctx->chroma_intra_matrix;
3925
3926	/* for mjpeg, we do include qscale in the matrix */
3927	for(i=1;i<64;i++){
3928	int j = s->idsp.idct_permutation[i];
3929
3930	s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3931	s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3932	}
3933	s->y_dc_scale_table=
3934	s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3935	s->chroma_intra_matrix[0] =
3936	s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3937	ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3938	s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3939	ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3940	s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3941	s->qscale= 8;
3942	}
3943	if(s->codec_id == AV_CODEC_ID_AMV){
3944	static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
3945	static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
3946	for(i=1;i<64;i++){
3947	int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3948
3949	s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3950	s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3951	}
3952	s->y_dc_scale_table= y;
3953	s->c_dc_scale_table= c;
3954	s->intra_matrix[0] = 13;
3955	s->chroma_intra_matrix[0] = 14;
3956	ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3957	s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3958	ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3959	s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3960	s->qscale= 8;
3961	}
3962
3963	//FIXME var duplication
3964	s->current_picture_ptr->f->key_frame =
3965	s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3966	s->current_picture_ptr->f->pict_type =
3967	s->current_picture.f->pict_type = s->pict_type;
3968
3969	if (s->current_picture.f->key_frame)
3970	s->picture_in_gop_number=0;
3971
3972	s->mb_x = s->mb_y = 0;
3973	s->last_bits= put_bits_count(&s->pb);
3974	switch(s->out_format) {
3975	case FMT_MJPEG:
3976	if (CONFIG_MJPEG_ENCODER && s->huffman != HUFFMAN_TABLE_OPTIMAL)
3977	ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3978	s->pred, s->intra_matrix, s->chroma_intra_matrix);
3979	break;
3980	case FMT_H261:
3981	if (CONFIG_H261_ENCODER)
3982	ff_h261_encode_picture_header(s, picture_number);
3983	break;
3984	case FMT_H263:
3985	if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3986	ff_wmv2_encode_picture_header(s, picture_number);
3987	else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3988	ff_msmpeg4_encode_picture_header(s, picture_number);
3989	else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3990	ret = ff_mpeg4_encode_picture_header(s, picture_number);
3991	if (ret < 0)
3992	return ret;
3993	} else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3994	ret = ff_rv10_encode_picture_header(s, picture_number);
3995	if (ret < 0)
3996	return ret;
3997	}
3998	else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3999	ff_rv20_encode_picture_header(s, picture_number);
4000	else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
4001	ff_flv_encode_picture_header(s, picture_number);
4002	else if (CONFIG_H263_ENCODER)
4003	ff_h263_encode_picture_header(s, picture_number);
4004	break;
4005	case FMT_MPEG1:
4006	if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
4007	ff_mpeg1_encode_picture_header(s, picture_number);
4008	break;
4009	default:
4010	av_assert0(0);
4011	}
4012	bits= put_bits_count(&s->pb);
4013	s->header_bits= bits - s->last_bits;
4014
4015	for(i=1; i<context_count; i++){
4016	update_duplicate_context_after_me(s->thread_context[i], s);
4017	}
4018	s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
4019	for(i=1; i<context_count; i++){
4020	if (s->pb.buf_end == s->thread_context[i]->pb.buf)
4021	set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
4022	merge_context_after_encode(s, s->thread_context[i]);
4023	}
4024	emms_c();
4025	return 0;
4026	}
4027
4028	static void denoise_dct_c(MpegEncContext *s, int16_t *block){
4029	const int intra= s->mb_intra;
4030	int i;
4031
4032	s->dct_count[intra]++;
4033
4034	for(i=0; i<64; i++){
4035	int level= block[i];
4036
4037	if(level){
4038	if(level>0){
4039	s->dct_error_sum[intra][i] += level;
4040	level -= s->dct_offset[intra][i];
4041	if(level<0) level=0;
4042	}else{
4043	s->dct_error_sum[intra][i] -= level;
4044	level += s->dct_offset[intra][i];
4045	if(level>0) level=0;
4046	}
4047	block[i]= level;
4048	}
4049	}
4050	}
4051
4052	static int dct_quantize_trellis_c(MpegEncContext *s,
4053	int16_t *block, int n,
4054	int qscale, int *overflow){
4055	const int *qmat;
4056	const uint16_t *matrix;
4057	const uint8_t *scantable= s->intra_scantable.scantable;
4058	const uint8_t *perm_scantable= s->intra_scantable.permutated;
4059	int max=0;
4060	unsigned int threshold1, threshold2;
4061	int bias=0;
4062	int run_tab[65];
4063	int level_tab[65];
4064	int score_tab[65];
4065	int survivor[65];
4066	int survivor_count;
4067	int last_run=0;
4068	int last_level=0;
4069	int last_score= 0;
4070	int last_i;
4071	int coeff[2][64];
4072	int coeff_count[64];
4073	int qmul, qadd, start_i, last_non_zero, i, dc;
4074	const int esc_length= s->ac_esc_length;
4075	uint8_t * length;
4076	uint8_t * last_length;
4077	const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4078	int mpeg2_qscale;
4079
4080	s->fdsp.fdct(block);
4081
4082	if(s->dct_error_sum)
4083	s->denoise_dct(s, block);
4084	qmul= qscale*16;
4085	qadd= ((qscale-1)|1)*8;
4086
4087	if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
4088	else mpeg2_qscale = qscale << 1;
4089
4090	if (s->mb_intra) {
4091	int q;
4092	if (!s->h263_aic) {
4093	if (n < 4)
4094	q = s->y_dc_scale;
4095	else
4096	q = s->c_dc_scale;
4097	q = q << 3;
4098	} else{
4099	/* For AIC we skip quant/dequant of INTRADC */
4100	q = 1 << 3;
4101	qadd=0;
4102	}
4103
4104	/* note: block[0] is assumed to be positive */
4105	block[0] = (block[0] + (q >> 1)) / q;
4106	start_i = 1;
4107	last_non_zero = 0;
4108	qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4109	matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4110	if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4111	bias= 1<<(QMAT_SHIFT-1);
4112
4113	if (n > 3 && s->intra_chroma_ac_vlc_length) {
4114	length = s->intra_chroma_ac_vlc_length;
4115	last_length= s->intra_chroma_ac_vlc_last_length;
4116	} else {
4117	length = s->intra_ac_vlc_length;
4118	last_length= s->intra_ac_vlc_last_length;
4119	}
4120	} else {
4121	start_i = 0;
4122	last_non_zero = -1;
4123	qmat = s->q_inter_matrix[qscale];
4124	matrix = s->inter_matrix;
4125	length = s->inter_ac_vlc_length;
4126	last_length= s->inter_ac_vlc_last_length;
4127	}
4128	last_i= start_i;
4129
4130	threshold1= (1<<QMAT_SHIFT) - bias - 1;
4131	threshold2= (threshold1<<1);
4132
4133	for(i=63; i>=start_i; i--) {
4134	const int j = scantable[i];
4135	int level = block[j] * qmat[j];
4136
4137	if(((unsigned)(level+threshold1))>threshold2){
4138	last_non_zero = i;
4139	break;
4140	}
4141	}
4142
4143	for(i=start_i; i<=last_non_zero; i++) {
4144	const int j = scantable[i];
4145	int level = block[j] * qmat[j];
4146
4147	// if( bias+level >= (1<<(QMAT_SHIFT - 3))
4148	// || bias-level >= (1<<(QMAT_SHIFT - 3))){
4149	if(((unsigned)(level+threshold1))>threshold2){
4150	if(level>0){
4151	level= (bias + level)>>QMAT_SHIFT;
4152	coeff[0][i]= level;
4153	coeff[1][i]= level-1;
4154	// coeff[2][k]= level-2;
4155	}else{
4156	level= (bias - level)>>QMAT_SHIFT;
4157	coeff[0][i]= -level;
4158	coeff[1][i]= -level+1;
4159	// coeff[2][k]= -level+2;
4160	}
4161	coeff_count[i]= FFMIN(level, 2);
4162	av_assert2(coeff_count[i]);
4163	max |=level;
4164	}else{
4165	coeff[0][i]= (level>>31)|1;
4166	coeff_count[i]= 1;
4167	}
4168	}
4169
4170	*overflow= s->max_qcoeff < max; //overflow might have happened
4171
4172	if(last_non_zero < start_i){
4173	memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4174	return last_non_zero;
4175	}
4176
4177	score_tab[start_i]= 0;
4178	survivor[0]= start_i;
4179	survivor_count= 1;
4180
4181	for(i=start_i; i<=last_non_zero; i++){
4182	int level_index, j, zero_distortion;
4183	int dct_coeff= FFABS(block[ scantable[i] ]);
4184	int best_score=256*256*256*120;
4185
4186	if (s->fdsp.fdct == ff_fdct_ifast)
4187	dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4188	zero_distortion= dct_coeff*dct_coeff;
4189
4190	for(level_index=0; level_index < coeff_count[i]; level_index++){
4191	int distortion;
4192	int level= coeff[level_index][i];
4193	const int alevel= FFABS(level);
4194	int unquant_coeff;
4195
4196	av_assert2(level);
4197
4198	if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4199	unquant_coeff= alevel*qmul + qadd;
4200	} else if(s->out_format == FMT_MJPEG) {
4201	j = s->idsp.idct_permutation[scantable[i]];
4202	unquant_coeff = alevel * matrix[j] * 8;
4203	}else{ // MPEG-1
4204	j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4205	if(s->mb_intra){
4206	unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4207	unquant_coeff = (unquant_coeff - 1) | 1;
4208	}else{
4209	unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4210	unquant_coeff = (unquant_coeff - 1) | 1;
4211	}
4212	unquant_coeff<<= 3;
4213	}
4214
4215	distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4216	level+=64;
4217	if((level&(~127)) == 0){
4218	for(j=survivor_count-1; j>=0; j--){
4219	int run= i - survivor[j];
4220	int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4221	score += score_tab[i-run];
4222
4223	if(score < best_score){
4224	best_score= score;
4225	run_tab[i+1]= run;
4226	level_tab[i+1]= level-64;
4227	}
4228	}
4229
4230	if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4231	for(j=survivor_count-1; j>=0; j--){
4232	int run= i - survivor[j];
4233	int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4234	score += score_tab[i-run];
4235	if(score < last_score){
4236	last_score= score;
4237	last_run= run;
4238	last_level= level-64;
4239	last_i= i+1;
4240	}
4241	}
4242	}
4243	}else{
4244	distortion += esc_length*lambda;
4245	for(j=survivor_count-1; j>=0; j--){
4246	int run= i - survivor[j];
4247	int score= distortion + score_tab[i-run];
4248
4249	if(score < best_score){
4250	best_score= score;
4251	run_tab[i+1]= run;
4252	level_tab[i+1]= level-64;
4253	}
4254	}
4255
4256	if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4257	for(j=survivor_count-1; j>=0; j--){
4258	int run= i - survivor[j];
4259	int score= distortion + score_tab[i-run];
4260	if(score < last_score){
4261	last_score= score;
4262	last_run= run;
4263	last_level= level-64;
4264	last_i= i+1;
4265	}
4266	}
4267	}
4268	}
4269	}
4270
4271	score_tab[i+1]= best_score;
4272
4273	// Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
4274	if(last_non_zero <= 27){
4275	for(; survivor_count; survivor_count--){
4276	if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4277	break;
4278	}
4279	}else{
4280	for(; survivor_count; survivor_count--){
4281	if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4282	break;
4283	}
4284	}
4285
4286	survivor[ survivor_count++ ]= i+1;
4287	}
4288
4289	if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4290	last_score= 256*256*256*120;
4291	for(i= survivor[0]; i<=last_non_zero + 1; i++){
4292	int score= score_tab[i];
4293	if (i)
4294	score += lambda * 2; // FIXME more exact?
4295
4296	if(score < last_score){
4297	last_score= score;
4298	last_i= i;
4299	last_level= level_tab[i];
4300	last_run= run_tab[i];
4301	}
4302	}
4303	}
4304
4305	s->coded_score[n] = last_score;
4306
4307	dc= FFABS(block[0]);
4308	last_non_zero= last_i - 1;
4309	memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4310
4311	if(last_non_zero < start_i)
4312	return last_non_zero;
4313
4314	if(last_non_zero == 0 && start_i == 0){
4315	int best_level= 0;
4316	int best_score= dc * dc;
4317
4318	for(i=0; i<coeff_count[0]; i++){
4319	int level= coeff[i][0];
4320	int alevel= FFABS(level);
4321	int unquant_coeff, score, distortion;
4322
4323	if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4324	unquant_coeff= (alevel*qmul + qadd)>>3;
4325	} else{ // MPEG-1
4326	unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4327	unquant_coeff = (unquant_coeff - 1) | 1;
4328	}
4329	unquant_coeff = (unquant_coeff + 4) >> 3;
4330	unquant_coeff<<= 3 + 3;
4331
4332	distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4333	level+=64;
4334	if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4335	else score= distortion + esc_length*lambda;
4336
4337	if(score < best_score){
4338	best_score= score;
4339	best_level= level - 64;
4340	}
4341	}
4342	block[0]= best_level;
4343	s->coded_score[n] = best_score - dc*dc;
4344	if(best_level == 0) return -1;
4345	else return last_non_zero;
4346	}
4347
4348	i= last_i;
4349	av_assert2(last_level);
4350
4351	block[ perm_scantable[last_non_zero] ]= last_level;
4352	i -= last_run + 1;
4353
4354	for(; i>start_i; i -= run_tab[i] + 1){
4355	block[ perm_scantable[i-1] ]= level_tab[i];
4356	}
4357
4358	return last_non_zero;
4359	}
4360
4361	//#define REFINE_STATS 1
4362	static int16_t basis[64][64];
4363
4364	static void build_basis(uint8_t *perm){
4365	int i, j, x, y;
4366	emms_c();
4367	for(i=0; i<8; i++){
4368	for(j=0; j<8; j++){
4369	for(y=0; y<8; y++){
4370	for(x=0; x<8; x++){
4371	double s= 0.25*(1<<BASIS_SHIFT);
4372	int index= 8*i + j;
4373	int perm_index= perm[index];
4374	if(i==0) s*= sqrt(0.5);
4375	if(j==0) s*= sqrt(0.5);
4376	basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
4377	}
4378	}
4379	}
4380	}
4381	}
4382
4383	static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4384	int16_t *block, int16_t *weight, int16_t *orig,
4385	int n, int qscale){
4386	int16_t rem[64];
4387	LOCAL_ALIGNED_16(int16_t, d1, [64]);
4388	const uint8_t *scantable= s->intra_scantable.scantable;
4389	const uint8_t *perm_scantable= s->intra_scantable.permutated;
4390	// unsigned int threshold1, threshold2;
4391	// int bias=0;
4392	int run_tab[65];
4393	int prev_run=0;
4394	int prev_level=0;
4395	int qmul, qadd, start_i, last_non_zero, i, dc;
4396	uint8_t * length;
4397	uint8_t * last_length;
4398	int lambda;
4399	int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4400	#ifdef REFINE_STATS
4401	static int count=0;
4402	static int after_last=0;
4403	static int to_zero=0;
4404	static int from_zero=0;
4405	static int raise=0;
4406	static int lower=0;
4407	static int messed_sign=0;
4408	#endif
4409
4410	if(basis[0][0] == 0)
4411	build_basis(s->idsp.idct_permutation);
4412
4413	qmul= qscale*2;
4414	qadd= (qscale-1)|1;
4415	if (s->mb_intra) {
4416	if (!s->h263_aic) {
4417	if (n < 4)
4418	q = s->y_dc_scale;
4419	else
4420	q = s->c_dc_scale;
4421	} else{
4422	/* For AIC we skip quant/dequant of INTRADC */
4423	q = 1;
4424	qadd=0;
4425	}
4426	q <<= RECON_SHIFT-3;
4427	/* note: block[0] is assumed to be positive */
4428	dc= block[0]*q;
4429	// block[0] = (block[0] + (q >> 1)) / q;
4430	start_i = 1;
4431	// if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4432	// bias= 1<<(QMAT_SHIFT-1);
4433	if (n > 3 && s->intra_chroma_ac_vlc_length) {
4434	length = s->intra_chroma_ac_vlc_length;
4435	last_length= s->intra_chroma_ac_vlc_last_length;
4436	} else {
4437	length = s->intra_ac_vlc_length;
4438	last_length= s->intra_ac_vlc_last_length;
4439	}
4440	} else {
4441	dc= 0;
4442	start_i = 0;
4443	length = s->inter_ac_vlc_length;
4444	last_length= s->inter_ac_vlc_last_length;
4445	}
4446	last_non_zero = s->block_last_index[n];
4447
4448	#ifdef REFINE_STATS
4449	{START_TIMER
4450	#endif
4451	dc += (1<<(RECON_SHIFT-1));
4452	for(i=0; i<64; i++){
4453	rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4454	}
4455	#ifdef REFINE_STATS
4456	STOP_TIMER("memset rem[]")}
4457	#endif
4458	sum=0;
4459	for(i=0; i<64; i++){
4460	int one= 36;
4461	int qns=4;
4462	int w;
4463
4464	w= FFABS(weight[i]) + qns*one;
4465	w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4466
4467	weight[i] = w;
4468	// w=weight[i] = (63*qns + (w/2)) / w;
4469
4470	av_assert2(w>0);
4471	av_assert2(w<(1<<6));
4472	sum += w*w;
4473	}
4474	lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4475	#ifdef REFINE_STATS
4476	{START_TIMER
4477	#endif
4478	run=0;
4479	rle_index=0;
4480	for(i=start_i; i<=last_non_zero; i++){
4481	int j= perm_scantable[i];
4482	const int level= block[j];
4483	int coeff;
4484
4485	if(level){
4486	if(level<0) coeff= qmul*level - qadd;
4487	else coeff= qmul*level + qadd;
4488	run_tab[rle_index++]=run;
4489	run=0;
4490
4491	s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4492	}else{
4493	run++;
4494	}
4495	}
4496	#ifdef REFINE_STATS
4497	if(last_non_zero>0){
4498	STOP_TIMER("init rem[]")
4499	}
4500	}
4501
4502	{START_TIMER
4503	#endif
4504	for(;;){
4505	int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4506	int best_coeff=0;
4507	int best_change=0;
4508	int run2, best_unquant_change=0, analyze_gradient;
4509	#ifdef REFINE_STATS
4510	{START_TIMER
4511	#endif
4512	analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4513
4514	if(analyze_gradient){
4515	#ifdef REFINE_STATS
4516	{START_TIMER
4517	#endif
4518	for(i=0; i<64; i++){
4519	int w= weight[i];
4520
4521	d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4522	}
4523	#ifdef REFINE_STATS
4524	STOP_TIMER("rem*w*w")}
4525	{START_TIMER
4526	#endif
4527	s->fdsp.fdct(d1);
4528	#ifdef REFINE_STATS
4529	STOP_TIMER("dct")}
4530	#endif
4531	}
4532
4533	if(start_i){
4534	const int level= block[0];
4535	int change, old_coeff;
4536
4537	av_assert2(s->mb_intra);
4538
4539	old_coeff= q*level;
4540
4541	for(change=-1; change<=1; change+=2){
4542	int new_level= level + change;
4543	int score, new_coeff;
4544
4545	new_coeff= q*new_level;
4546	if(new_coeff >= 2048 || new_coeff < 0)
4547	continue;
4548
4549	score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4550	new_coeff - old_coeff);
4551	if(score<best_score){
4552	best_score= score;
4553	best_coeff= 0;
4554	best_change= change;
4555	best_unquant_change= new_coeff - old_coeff;
4556	}
4557	}
4558	}
4559
4560	run=0;
4561	rle_index=0;
4562	run2= run_tab[rle_index++];
4563	prev_level=0;
4564	prev_run=0;
4565
4566	for(i=start_i; i<64; i++){
4567	int j= perm_scantable[i];
4568	const int level= block[j];
4569	int change, old_coeff;
4570
4571	if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4572	break;
4573
4574	if(level){
4575	if(level<0) old_coeff= qmul*level - qadd;
4576	else old_coeff= qmul*level + qadd;
4577	run2= run_tab[rle_index++]; //FIXME ! maybe after last
4578	}else{
4579	old_coeff=0;
4580	run2--;
4581	av_assert2(run2>=0 || i >= last_non_zero );
4582	}
4583
4584	for(change=-1; change<=1; change+=2){
4585	int new_level= level + change;
4586	int score, new_coeff, unquant_change;
4587
4588	score=0;
4589	if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4590	continue;
4591
4592	if(new_level){
4593	if(new_level<0) new_coeff= qmul*new_level - qadd;
4594	else new_coeff= qmul*new_level + qadd;
4595	if(new_coeff >= 2048 || new_coeff <= -2048)
4596	continue;
4597	//FIXME check for overflow
4598
4599	if(level){
4600	if(level < 63 && level > -63){
4601	if(i < last_non_zero)
4602	score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4603	- length[UNI_AC_ENC_INDEX(run, level+64)];
4604	else
4605	score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4606	- last_length[UNI_AC_ENC_INDEX(run, level+64)];
4607	}
4608	}else{
4609	av_assert2(FFABS(new_level)==1);
4610
4611	if(analyze_gradient){
4612	int g= d1[ scantable[i] ];
4613	if(g && (g^new_level) >= 0)
4614	continue;
4615	}
4616
4617	if(i < last_non_zero){
4618	int next_i= i + run2 + 1;
4619	int next_level= block[ perm_scantable[next_i] ] + 64;
4620
4621	if(next_level&(~127))
4622	next_level= 0;
4623
4624	if(next_i < last_non_zero)
4625	score += length[UNI_AC_ENC_INDEX(run, 65)]
4626	+ length[UNI_AC_ENC_INDEX(run2, next_level)]
4627	- length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4628	else
4629	score += length[UNI_AC_ENC_INDEX(run, 65)]
4630	+ last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4631	- last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4632	}else{
4633	score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4634	if(prev_level){
4635	score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4636	- last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4637	}
4638	}
4639	}
4640	}else{
4641	new_coeff=0;
4642	av_assert2(FFABS(level)==1);
4643
4644	if(i < last_non_zero){
4645	int next_i= i + run2 + 1;
4646	int next_level= block[ perm_scantable[next_i] ] + 64;
4647
4648	if(next_level&(~127))
4649	next_level= 0;
4650
4651	if(next_i < last_non_zero)
4652	score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4653	- length[UNI_AC_ENC_INDEX(run2, next_level)]
4654	- length[UNI_AC_ENC_INDEX(run, 65)];
4655	else
4656	score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4657	- last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4658	- length[UNI_AC_ENC_INDEX(run, 65)];
4659	}else{
4660	score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4661	if(prev_level){
4662	score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4663	- length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4664	}
4665	}
4666	}
4667
4668	score *= lambda;
4669
4670	unquant_change= new_coeff - old_coeff;
4671	av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4672
4673	score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4674	unquant_change);
4675	if(score<best_score){
4676	best_score= score;
4677	best_coeff= i;
4678	best_change= change;
4679	best_unquant_change= unquant_change;
4680	}
4681	}
4682	if(level){
4683	prev_level= level + 64;
4684	if(prev_level&(~127))
4685	prev_level= 0;
4686	prev_run= run;
4687	run=0;
4688	}else{
4689	run++;
4690	}
4691	}
4692	#ifdef REFINE_STATS
4693	STOP_TIMER("iterative step")}
4694	#endif
4695
4696	if(best_change){
4697	int j= perm_scantable[ best_coeff ];
4698
4699	block[j] += best_change;
4700
4701	if(best_coeff > last_non_zero){
4702	last_non_zero= best_coeff;
4703	av_assert2(block[j]);
4704	#ifdef REFINE_STATS
4705	after_last++;
4706	#endif
4707	}else{
4708	#ifdef REFINE_STATS
4709	if(block[j]){
4710	if(block[j] - best_change){
4711	if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4712	raise++;
4713	}else{
4714	lower++;
4715	}
4716	}else{
4717	from_zero++;
4718	}
4719	}else{
4720	to_zero++;
4721	}
4722	#endif
4723	for(; last_non_zero>=start_i; last_non_zero--){
4724	if(block[perm_scantable[last_non_zero]])
4725	break;
4726	}
4727	}
4728	#ifdef REFINE_STATS
4729	count++;
4730	if(256*256*256*64 % count == 0){
4731	av_log(s->avctx, AV_LOG_DEBUG, "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);
4732	}
4733	#endif
4734	run=0;
4735	rle_index=0;
4736	for(i=start_i; i<=last_non_zero; i++){
4737	int j= perm_scantable[i];
4738	const int level= block[j];
4739
4740	if(level){
4741	run_tab[rle_index++]=run;
4742	run=0;
4743	}else{
4744	run++;
4745	}
4746	}
4747
4748	s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4749	}else{
4750	break;
4751	}
4752	}
4753	#ifdef REFINE_STATS
4754	if(last_non_zero>0){
4755	STOP_TIMER("iterative search")
4756	}
4757	}
4758	#endif
4759
4760	return last_non_zero;
4761	}
4762
4763	/**
4764	* Permute an 8x8 block according to permutation.
4765	* @param block the block which will be permuted according to
4766	* the given permutation vector
4767	* @param permutation the permutation vector
4768	* @param last the last non zero coefficient in scantable order, used to
4769	* speed the permutation up
4770	* @param scantable the used scantable, this is only used to speed the
4771	* permutation up, the block is not (inverse) permutated
4772	* to scantable order!
4773	*/
4774	void ff_block_permute(int16_t *block, uint8_t *permutation,
4775	const uint8_t *scantable, int last)
4776	{
4777	int i;
4778	int16_t temp[64];
4779
4780	if (last <= 0)
4781	return;
4782	//FIXME it is ok but not clean and might fail for some permutations
4783	// if (permutation[1] == 1)
4784	// return;
4785
4786	for (i = 0; i <= last; i++) {
4787	const int j = scantable[i];
4788	temp[j] = block[j];
4789	block[j] = 0;
4790	}
4791
4792	for (i = 0; i <= last; i++) {
4793	const int j = scantable[i];
4794	const int perm_j = permutation[j];
4795	block[perm_j] = temp[j];
4796	}
4797	}
4798
4799	int ff_dct_quantize_c(MpegEncContext *s,
4800	int16_t *block, int n,
4801	int qscale, int *overflow)
4802	{
4803	int i, j, level, last_non_zero, q, start_i;
4804	const int *qmat;
4805	const uint8_t *scantable= s->intra_scantable.scantable;
4806	int bias;
4807	int max=0;
4808	unsigned int threshold1, threshold2;
4809
4810	s->fdsp.fdct(block);
4811
4812	if(s->dct_error_sum)
4813	s->denoise_dct(s, block);
4814
4815	if (s->mb_intra) {
4816	if (!s->h263_aic) {
4817	if (n < 4)
4818	q = s->y_dc_scale;
4819	else
4820	q = s->c_dc_scale;
4821	q = q << 3;
4822	} else
4823	/* For AIC we skip quant/dequant of INTRADC */
4824	q = 1 << 3;
4825
4826	/* note: block[0] is assumed to be positive */
4827	block[0] = (block[0] + (q >> 1)) / q;
4828	start_i = 1;
4829	last_non_zero = 0;
4830	qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4831	bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4832	} else {
4833	start_i = 0;
4834	last_non_zero = -1;
4835	qmat = s->q_inter_matrix[qscale];
4836	bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4837	}
4838	threshold1= (1<<QMAT_SHIFT) - bias - 1;
4839	threshold2= (threshold1<<1);
4840	for(i=63;i>=start_i;i--) {
4841	j = scantable[i];
4842	level = block[j] * qmat[j];
4843
4844	if(((unsigned)(level+threshold1))>threshold2){
4845	last_non_zero = i;
4846	break;
4847	}else{
4848	block[j]=0;
4849	}
4850	}
4851	for(i=start_i; i<=last_non_zero; i++) {
4852	j = scantable[i];
4853	level = block[j] * qmat[j];
4854
4855	// if( bias+level >= (1<<QMAT_SHIFT)
4856	// || bias-level >= (1<<QMAT_SHIFT)){
4857	if(((unsigned)(level+threshold1))>threshold2){
4858	if(level>0){
4859	level= (bias + level)>>QMAT_SHIFT;
4860	block[j]= level;
4861	}else{
4862	level= (bias - level)>>QMAT_SHIFT;
4863	block[j]= -level;
4864	}
4865	max |=level;
4866	}else{
4867	block[j]=0;
4868	}
4869	}
4870	*overflow= s->max_qcoeff < max; //overflow might have happened
4871
4872	/* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4873	if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4874	ff_block_permute(block, s->idsp.idct_permutation,
4875	scantable, last_non_zero);
4876
4877	return last_non_zero;
4878	}
4879
4880	#define OFFSET(x) offsetof(MpegEncContext, x)
4881	#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4882	static const AVOption h263_options[] = {
4883	{ "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4884	{ "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4885	FF_MPV_COMMON_OPTS
4886	{ NULL },
4887	};
4888
4889	static const AVClass h263_class = {
4890	.class_name = "H.263 encoder",
4891	.item_name = av_default_item_name,
4892	.option = h263_options,
4893	.version = LIBAVUTIL_VERSION_INT,
4894	};
4895
4896	AVCodec ff_h263_encoder = {
4897	.name = "h263",
4898	.long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4899	.type = AVMEDIA_TYPE_VIDEO,
4900	.id = AV_CODEC_ID_H263,
4901	.priv_data_size = sizeof(MpegEncContext),
4902	.init = ff_mpv_encode_init,
4903	.encode2 = ff_mpv_encode_picture,
4904	.close = ff_mpv_encode_end,
4905	.pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4906	.priv_class = &h263_class,
4907	};
4908
4909	static const AVOption h263p_options[] = {
4910	{ "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4911	{ "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4912	{ "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4913	{ "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
4914	FF_MPV_COMMON_OPTS
4915	{ NULL },
4916	};
4917	static const AVClass h263p_class = {
4918	.class_name = "H.263p encoder",
4919	.item_name = av_default_item_name,
4920	.option = h263p_options,
4921	.version = LIBAVUTIL_VERSION_INT,
4922	};
4923
4924	AVCodec ff_h263p_encoder = {
4925	.name = "h263p",
4926	.long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4927	.type = AVMEDIA_TYPE_VIDEO,
4928	.id = AV_CODEC_ID_H263P,
4929	.priv_data_size = sizeof(MpegEncContext),
4930	.init = ff_mpv_encode_init,
4931	.encode2 = ff_mpv_encode_picture,
4932	.close = ff_mpv_encode_end,
4933	.capabilities = AV_CODEC_CAP_SLICE_THREADS,
4934	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4935	.priv_class = &h263p_class,
4936	};
4937
4938	static const AVClass msmpeg4v2_class = {
4939	.class_name = "msmpeg4v2 encoder",
4940	.item_name = av_default_item_name,
4941	.option = ff_mpv_generic_options,
4942	.version = LIBAVUTIL_VERSION_INT,
4943	};
4944
4945	AVCodec ff_msmpeg4v2_encoder = {
4946	.name = "msmpeg4v2",
4947	.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4948	.type = AVMEDIA_TYPE_VIDEO,
4949	.id = AV_CODEC_ID_MSMPEG4V2,
4950	.priv_data_size = sizeof(MpegEncContext),
4951	.init = ff_mpv_encode_init,
4952	.encode2 = ff_mpv_encode_picture,
4953	.close = ff_mpv_encode_end,
4954	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4955	.priv_class = &msmpeg4v2_class,
4956	};
4957
4958	static const AVClass msmpeg4v3_class = {
4959	.class_name = "msmpeg4v3 encoder",
4960	.item_name = av_default_item_name,
4961	.option = ff_mpv_generic_options,
4962	.version = LIBAVUTIL_VERSION_INT,
4963	};
4964
4965	AVCodec ff_msmpeg4v3_encoder = {
4966	.name = "msmpeg4",
4967	.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4968	.type = AVMEDIA_TYPE_VIDEO,
4969	.id = AV_CODEC_ID_MSMPEG4V3,
4970	.priv_data_size = sizeof(MpegEncContext),
4971	.init = ff_mpv_encode_init,
4972	.encode2 = ff_mpv_encode_picture,
4973	.close = ff_mpv_encode_end,
4974	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4975	.priv_class = &msmpeg4v3_class,
4976	};
4977
4978	static const AVClass wmv1_class = {
4979	.class_name = "wmv1 encoder",
4980	.item_name = av_default_item_name,
4981	.option = ff_mpv_generic_options,
4982	.version = LIBAVUTIL_VERSION_INT,
4983	};
4984
4985	AVCodec ff_wmv1_encoder = {
4986	.name = "wmv1",
4987	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4988	.type = AVMEDIA_TYPE_VIDEO,
4989	.id = AV_CODEC_ID_WMV1,
4990	.priv_data_size = sizeof(MpegEncContext),
4991	.init = ff_mpv_encode_init,
4992	.encode2 = ff_mpv_encode_picture,
4993	.close = ff_mpv_encode_end,
4994	.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4995	.priv_class = &wmv1_class,
4996	};
4997