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