second try of improved lambda/qp guessing for motion estimation RD in first pass
[libav.git] / libavcodec / mpegvideo.c
1 /*
2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21 */
22
23 /**
24 * @file mpegvideo.c
25 * The simplest mpeg encoder (well, it was the simplest!).
26 */
27
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "mpegvideo.h"
31 #include "faandct.h"
32 #include <limits.h>
33
34 #ifdef USE_FASTMEMCPY
35 #include "fastmemcpy.h"
36 #endif
37
38 //#undef NDEBUG
39 //#include <assert.h>
40
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 static int sse_mb(MpegEncContext *s);
62 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 #endif //CONFIG_ENCODERS
64
65 #ifdef HAVE_XVMC
66 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67 extern void XVMC_field_end(MpegEncContext *s);
68 extern void XVMC_decode_mb(MpegEncContext *s);
69 #endif
70
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
72
73
74 /* enable all paranoid tests for rounding, overflows, etc... */
75 //#define PARANOID
76
77 //#define DEBUG
78
79
80 /* for jpeg fast DCT */
81 #define CONST_BITS 14
82
83 static const uint16_t aanscales[64] = {
84 /* precomputed values scaled up by 14 bits */
85 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
86 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
87 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
88 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
91 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
92 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
93 };
94
95 static const uint8_t h263_chroma_roundtab[16] = {
96 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
97 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
98 };
99
100 static const uint8_t ff_default_chroma_qscale_table[32]={
101 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
102 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
103 };
104
105 #ifdef CONFIG_ENCODERS
106 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 static uint8_t default_fcode_tab[MAX_MV*2+1];
108
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
110
111 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
113 {
114 int qscale;
115 int shift=0;
116
117 for(qscale=qmin; qscale<=qmax; qscale++){
118 int i;
119 if (dsp->fdct == ff_jpeg_fdct_islow
120 #ifdef FAAN_POSTSCALE
121 || dsp->fdct == ff_faandct
122 #endif
123 ) {
124 for(i=0;i<64;i++) {
125 const int j= dsp->idct_permutation[i];
126 /* 16 <= qscale * quant_matrix[i] <= 7905 */
127 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
128 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130
131 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 (qscale * quant_matrix[j]));
133 }
134 } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136 || dsp->fdct == ff_faandct
137 #endif
138 ) {
139 for(i=0;i<64;i++) {
140 const int j= dsp->idct_permutation[i];
141 /* 16 <= qscale * quant_matrix[i] <= 7905 */
142 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
143 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145
146 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 (aanscales[i] * qscale * quant_matrix[j]));
148 }
149 } else {
150 for(i=0;i<64;i++) {
151 const int j= dsp->idct_permutation[i];
152 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153 So 16 <= qscale * quant_matrix[i] <= 7905
154 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
156 */
157 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160
161 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
163 }
164 }
165
166 for(i=intra; i<64; i++){
167 int64_t max= 8191;
168 if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170 || dsp->fdct == ff_faandct
171 #endif
172 ) {
173 max= (8191LL*aanscales[i]) >> 14;
174 }
175 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
176 shift++;
177 }
178 }
179 }
180 if(shift){
181 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
182 }
183 }
184
185 static inline void update_qscale(MpegEncContext *s){
186 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
188
189 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
190 }
191 #endif //CONFIG_ENCODERS
192
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
194 int i;
195 int end;
196
197 st->scantable= src_scantable;
198
199 for(i=0; i<64; i++){
200 int j;
201 j = src_scantable[i];
202 st->permutated[i] = permutation[j];
203 #ifdef ARCH_POWERPC
204 st->inverse[j] = i;
205 #endif
206 }
207
208 end=-1;
209 for(i=0; i<64; i++){
210 int j;
211 j = st->permutated[i];
212 if(j>end) end=j;
213 st->raster_end[i]= end;
214 }
215 }
216
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
219 int i;
220
221 if(matrix){
222 put_bits(pb, 1, 1);
223 for(i=0;i<64;i++) {
224 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
225 }
226 }else
227 put_bits(pb, 1, 0);
228 }
229 #endif //CONFIG_ENCODERS
230
231 /* init common dct for both encoder and decoder */
232 int DCT_common_init(MpegEncContext *s)
233 {
234 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240
241 #ifdef CONFIG_ENCODERS
242 s->dct_quantize= dct_quantize_c;
243 s->denoise_dct= denoise_dct_c;
244 #endif //CONFIG_ENCODERS
245
246 #ifdef HAVE_MMX
247 MPV_common_init_mmx(s);
248 #endif
249 #ifdef ARCH_ALPHA
250 MPV_common_init_axp(s);
251 #endif
252 #ifdef HAVE_MLIB
253 MPV_common_init_mlib(s);
254 #endif
255 #ifdef HAVE_MMI
256 MPV_common_init_mmi(s);
257 #endif
258 #ifdef ARCH_ARMV4L
259 MPV_common_init_armv4l(s);
260 #endif
261 #ifdef ARCH_POWERPC
262 MPV_common_init_ppc(s);
263 #endif
264
265 #ifdef CONFIG_ENCODERS
266 s->fast_dct_quantize= s->dct_quantize;
267
268 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
270 }
271
272 #endif //CONFIG_ENCODERS
273
274 /* load & permutate scantables
275 note: only wmv uses different ones
276 */
277 if(s->alternate_scan){
278 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
279 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
280 }else{
281 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
282 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
283 }
284 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286
287 return 0;
288 }
289
290 static void copy_picture(Picture *dst, Picture *src){
291 *dst = *src;
292 dst->type= FF_BUFFER_TYPE_COPY;
293 }
294
295 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
296 int i;
297
298 dst->pict_type = src->pict_type;
299 dst->quality = src->quality;
300 dst->coded_picture_number = src->coded_picture_number;
301 dst->display_picture_number = src->display_picture_number;
302 // dst->reference = src->reference;
303 dst->pts = src->pts;
304 dst->interlaced_frame = src->interlaced_frame;
305 dst->top_field_first = src->top_field_first;
306
307 if(s->avctx->me_threshold){
308 if(!src->motion_val[0])
309 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
310 if(!src->mb_type)
311 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312 if(!src->ref_index[0])
313 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
316 src->motion_subsample_log2, dst->motion_subsample_log2);
317
318 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
319
320 for(i=0; i<2; i++){
321 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
323
324 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
326 }
327 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329 }
330 }
331 }
332 }
333
334 /**
335 * allocates a Picture
336 * The pixels are allocated/set by calling get_buffer() if shared=0
337 */
338 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340 const int mb_array_size= s->mb_stride*s->mb_height;
341 const int b8_array_size= s->b8_stride*s->mb_height*2;
342 const int b4_array_size= s->b4_stride*s->mb_height*4;
343 int i;
344
345 if(shared){
346 assert(pic->data[0]);
347 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348 pic->type= FF_BUFFER_TYPE_SHARED;
349 }else{
350 int r;
351
352 assert(!pic->data[0]);
353
354 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355
356 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
358 return -1;
359 }
360
361 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
363 return -1;
364 }
365
366 if(pic->linesize[1] != pic->linesize[2]){
367 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
368 return -1;
369 }
370
371 s->linesize = pic->linesize[0];
372 s->uvlinesize= pic->linesize[1];
373 }
374
375 if(pic->qscale_table==NULL){
376 if (s->encoding) {
377 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
378 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
380 }
381
382 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
385 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386 if(s->out_format == FMT_H264){
387 for(i=0; i<2; i++){
388 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
389 pic->motion_val[i]= pic->motion_val_base[i]+4;
390 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391 }
392 pic->motion_subsample_log2= 2;
393 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394 for(i=0; i<2; i++){
395 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
396 pic->motion_val[i]= pic->motion_val_base[i]+4;
397 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398 }
399 pic->motion_subsample_log2= 3;
400 }
401 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
403 }
404 pic->qstride= s->mb_stride;
405 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
406 }
407
408 //it might be nicer if the application would keep track of these but it would require a API change
409 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
410 s->prev_pict_types[0]= s->pict_type;
411 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
413
414 return 0;
415 fail: //for the CHECKED_ALLOCZ macro
416 return -1;
417 }
418
419 /**
420 * deallocates a picture
421 */
422 static void free_picture(MpegEncContext *s, Picture *pic){
423 int i;
424
425 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
427 }
428
429 av_freep(&pic->mb_var);
430 av_freep(&pic->mc_mb_var);
431 av_freep(&pic->mb_mean);
432 av_freep(&pic->mbskip_table);
433 av_freep(&pic->qscale_table);
434 av_freep(&pic->mb_type_base);
435 av_freep(&pic->dct_coeff);
436 av_freep(&pic->pan_scan);
437 pic->mb_type= NULL;
438 for(i=0; i<2; i++){
439 av_freep(&pic->motion_val_base[i]);
440 av_freep(&pic->ref_index[i]);
441 }
442
443 if(pic->type == FF_BUFFER_TYPE_SHARED){
444 for(i=0; i<4; i++){
445 pic->base[i]=
446 pic->data[i]= NULL;
447 }
448 pic->type= 0;
449 }
450 }
451
452 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
453 int i;
454
455 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
456 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458
459 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
461 s->rd_scratchpad= s->me.scratchpad;
462 s->b_scratchpad= s->me.scratchpad;
463 s->obmc_scratchpad= s->me.scratchpad + 16;
464 if (s->encoding) {
465 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
466 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467 if(s->avctx->noise_reduction){
468 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
469 }
470 }
471 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472 s->block= s->blocks[0];
473
474 for(i=0;i<12;i++){
475 s->pblocks[i] = (short *)(&s->block[i]);
476 }
477 return 0;
478 fail:
479 return -1; //free() through MPV_common_end()
480 }
481
482 static void free_duplicate_context(MpegEncContext *s){
483 if(s==NULL) return;
484
485 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486 av_freep(&s->me.scratchpad);
487 s->rd_scratchpad=
488 s->b_scratchpad=
489 s->obmc_scratchpad= NULL;
490
491 av_freep(&s->dct_error_sum);
492 av_freep(&s->me.map);
493 av_freep(&s->me.score_map);
494 av_freep(&s->blocks);
495 s->block= NULL;
496 }
497
498 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499 #define COPY(a) bak->a= src->a
500 COPY(allocated_edge_emu_buffer);
501 COPY(edge_emu_buffer);
502 COPY(me.scratchpad);
503 COPY(rd_scratchpad);
504 COPY(b_scratchpad);
505 COPY(obmc_scratchpad);
506 COPY(me.map);
507 COPY(me.score_map);
508 COPY(blocks);
509 COPY(block);
510 COPY(start_mb_y);
511 COPY(end_mb_y);
512 COPY(me.map_generation);
513 COPY(pb);
514 COPY(dct_error_sum);
515 COPY(dct_count[0]);
516 COPY(dct_count[1]);
517 #undef COPY
518 }
519
520 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521 MpegEncContext bak;
522 int i;
523 //FIXME copy only needed parts
524 //START_TIMER
525 backup_duplicate_context(&bak, dst);
526 memcpy(dst, src, sizeof(MpegEncContext));
527 backup_duplicate_context(dst, &bak);
528 for(i=0;i<12;i++){
529 dst->pblocks[i] = (short *)(&dst->block[i]);
530 }
531 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
532 }
533
534 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535 #define COPY(a) dst->a= src->a
536 COPY(pict_type);
537 COPY(current_picture);
538 COPY(f_code);
539 COPY(b_code);
540 COPY(qscale);
541 COPY(lambda);
542 COPY(lambda2);
543 COPY(picture_in_gop_number);
544 COPY(gop_picture_number);
545 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
546 COPY(progressive_frame); //FIXME don't set in encode_header
547 COPY(partitioned_frame); //FIXME don't set in encode_header
548 #undef COPY
549 }
550
551 /**
552 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553 * the changed fields will not depend upon the prior state of the MpegEncContext.
554 */
555 static void MPV_common_defaults(MpegEncContext *s){
556 s->y_dc_scale_table=
557 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558 s->chroma_qscale_table= ff_default_chroma_qscale_table;
559 s->progressive_frame= 1;
560 s->progressive_sequence= 1;
561 s->picture_structure= PICT_FRAME;
562
563 s->coded_picture_number = 0;
564 s->picture_number = 0;
565 s->input_picture_number = 0;
566
567 s->picture_in_gop_number = 0;
568
569 s->f_code = 1;
570 s->b_code = 1;
571 }
572
573 /**
574 * sets the given MpegEncContext to defaults for decoding.
575 * the changed fields will not depend upon the prior state of the MpegEncContext.
576 */
577 void MPV_decode_defaults(MpegEncContext *s){
578 MPV_common_defaults(s);
579 }
580
581 /**
582 * sets the given MpegEncContext to defaults for encoding.
583 * the changed fields will not depend upon the prior state of the MpegEncContext.
584 */
585
586 #ifdef CONFIG_ENCODERS
587 static void MPV_encode_defaults(MpegEncContext *s){
588 static int done=0;
589
590 MPV_common_defaults(s);
591
592 if(!done){
593 int i;
594 done=1;
595
596 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598
599 for(i=-16; i<16; i++){
600 default_fcode_tab[i + MAX_MV]= 1;
601 }
602 }
603 s->me.mv_penalty= default_mv_penalty;
604 s->fcode_tab= default_fcode_tab;
605 }
606 #endif //CONFIG_ENCODERS
607
608 /**
609 * init common structure for both encoder and decoder.
610 * this assumes that some variables like width/height are already set
611 */
612 int MPV_common_init(MpegEncContext *s)
613 {
614 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615
616 if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
618 return -1;
619 }
620
621 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
622 return -1;
623
624 dsputil_init(&s->dsp, s->avctx);
625 DCT_common_init(s);
626
627 s->flags= s->avctx->flags;
628 s->flags2= s->avctx->flags2;
629
630 s->mb_width = (s->width + 15) / 16;
631 s->mb_height = (s->height + 15) / 16;
632 s->mb_stride = s->mb_width + 1;
633 s->b8_stride = s->mb_width*2 + 1;
634 s->b4_stride = s->mb_width*4 + 1;
635 mb_array_size= s->mb_height * s->mb_stride;
636 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637
638 /* set chroma shifts */
639 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640 &(s->chroma_y_shift) );
641
642 /* set default edge pos, will be overriden in decode_header if needed */
643 s->h_edge_pos= s->mb_width*16;
644 s->v_edge_pos= s->mb_height*16;
645
646 s->mb_num = s->mb_width * s->mb_height;
647
648 s->block_wrap[0]=
649 s->block_wrap[1]=
650 s->block_wrap[2]=
651 s->block_wrap[3]= s->b8_stride;
652 s->block_wrap[4]=
653 s->block_wrap[5]= s->mb_stride;
654
655 y_size = s->b8_stride * (2 * s->mb_height + 1);
656 c_size = s->mb_stride * (s->mb_height + 1);
657 yc_size = y_size + 2 * c_size;
658
659 /* convert fourcc to upper case */
660 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
661 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664
665 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
666 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
669
670 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
671
672 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673 for(y=0; y<s->mb_height; y++){
674 for(x=0; x<s->mb_width; x++){
675 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
676 }
677 }
678 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679
680 if (s->encoding) {
681 /* Allocate MV tables */
682 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
683 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
684 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
685 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
688 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
689 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
690 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
691 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
694
695 if(s->msmpeg4_version){
696 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
697 }
698 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699
700 /* Allocate MB type table */
701 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
702
703 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704
705 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711
712 if(s->avctx->noise_reduction){
713 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
714 }
715 }
716 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
717
718 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719
720 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721 /* interlaced direct mode decoding tables */
722 for(i=0; i<2; i++){
723 int j, k;
724 for(j=0; j<2; j++){
725 for(k=0; k<2; k++){
726 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
727 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
728 }
729 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
730 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
731 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
732 }
733 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
734 }
735 }
736 if (s->out_format == FMT_H263) {
737 /* ac values */
738 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741 s->ac_val[2] = s->ac_val[1] + c_size;
742
743 /* cbp values */
744 CHECKED_ALLOCZ(s->coded_block_base, y_size);
745 s->coded_block= s->coded_block_base + s->b8_stride + 1;
746
747 /* cbp, ac_pred, pred_dir */
748 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
749 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750 }
751
752 if (s->h263_pred || s->h263_plus || !s->encoding) {
753 /* dc values */
754 //MN: we need these for error resilience of intra-frames
755 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758 s->dc_val[2] = s->dc_val[1] + c_size;
759 for(i=0;i<yc_size;i++)
760 s->dc_val_base[i] = 1024;
761 }
762
763 /* which mb is a intra block */
764 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765 memset(s->mbintra_table, 1, mb_array_size);
766
767 /* init macroblock skip table */
768 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769 //Note the +1 is for a quicker mpeg4 slice_end detection
770 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771
772 s->parse_context.state= -1;
773 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777 }
778
779 s->context_initialized = 1;
780
781 s->thread_context[0]= s;
782 for(i=1; i<s->avctx->thread_count; i++){
783 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
785 }
786
787 for(i=0; i<s->avctx->thread_count; i++){
788 if(init_duplicate_context(s->thread_context[i], s) < 0)
789 goto fail;
790 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
792 }
793
794 return 0;
795 fail:
796 MPV_common_end(s);
797 return -1;
798 }
799
800 /* init common structure for both encoder and decoder */
801 void MPV_common_end(MpegEncContext *s)
802 {
803 int i, j, k;
804
805 for(i=0; i<s->avctx->thread_count; i++){
806 free_duplicate_context(s->thread_context[i]);
807 }
808 for(i=1; i<s->avctx->thread_count; i++){
809 av_freep(&s->thread_context[i]);
810 }
811
812 av_freep(&s->parse_context.buffer);
813 s->parse_context.buffer_size=0;
814
815 av_freep(&s->mb_type);
816 av_freep(&s->p_mv_table_base);
817 av_freep(&s->b_forw_mv_table_base);
818 av_freep(&s->b_back_mv_table_base);
819 av_freep(&s->b_bidir_forw_mv_table_base);
820 av_freep(&s->b_bidir_back_mv_table_base);
821 av_freep(&s->b_direct_mv_table_base);
822 s->p_mv_table= NULL;
823 s->b_forw_mv_table= NULL;
824 s->b_back_mv_table= NULL;
825 s->b_bidir_forw_mv_table= NULL;
826 s->b_bidir_back_mv_table= NULL;
827 s->b_direct_mv_table= NULL;
828 for(i=0; i<2; i++){
829 for(j=0; j<2; j++){
830 for(k=0; k<2; k++){
831 av_freep(&s->b_field_mv_table_base[i][j][k]);
832 s->b_field_mv_table[i][j][k]=NULL;
833 }
834 av_freep(&s->b_field_select_table[i][j]);
835 av_freep(&s->p_field_mv_table_base[i][j]);
836 s->p_field_mv_table[i][j]=NULL;
837 }
838 av_freep(&s->p_field_select_table[i]);
839 }
840
841 av_freep(&s->dc_val_base);
842 av_freep(&s->ac_val_base);
843 av_freep(&s->coded_block_base);
844 av_freep(&s->mbintra_table);
845 av_freep(&s->cbp_table);
846 av_freep(&s->pred_dir_table);
847
848 av_freep(&s->mbskip_table);
849 av_freep(&s->prev_pict_types);
850 av_freep(&s->bitstream_buffer);
851 s->allocated_bitstream_buffer_size=0;
852
853 av_freep(&s->avctx->stats_out);
854 av_freep(&s->ac_stats);
855 av_freep(&s->error_status_table);
856 av_freep(&s->mb_index2xy);
857 av_freep(&s->lambda_table);
858 av_freep(&s->q_intra_matrix);
859 av_freep(&s->q_inter_matrix);
860 av_freep(&s->q_intra_matrix16);
861 av_freep(&s->q_inter_matrix16);
862 av_freep(&s->input_picture);
863 av_freep(&s->reordered_input_picture);
864 av_freep(&s->dct_offset);
865
866 if(s->picture){
867 for(i=0; i<MAX_PICTURE_COUNT; i++){
868 free_picture(s, &s->picture[i]);
869 }
870 }
871 av_freep(&s->picture);
872 s->context_initialized = 0;
873 s->last_picture_ptr=
874 s->next_picture_ptr=
875 s->current_picture_ptr= NULL;
876 s->linesize= s->uvlinesize= 0;
877
878 for(i=0; i<3; i++)
879 av_freep(&s->visualization_buffer[i]);
880
881 avcodec_default_free_buffers(s->avctx);
882 }
883
884 #ifdef CONFIG_ENCODERS
885
886 /* init video encoder */
887 int MPV_encode_init(AVCodecContext *avctx)
888 {
889 MpegEncContext *s = avctx->priv_data;
890 int i;
891 int chroma_h_shift, chroma_v_shift;
892
893 MPV_encode_defaults(s);
894
895 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
897 return -1;
898 }
899
900 if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901 if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
903 return -1;
904 }
905 }else{
906 if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
907 av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
908 return -1;
909 }
910 }
911
912 s->bit_rate = avctx->bit_rate;
913 s->width = avctx->width;
914 s->height = avctx->height;
915 if(avctx->gop_size > 600){
916 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917 avctx->gop_size=600;
918 }
919 s->gop_size = avctx->gop_size;
920 s->avctx = avctx;
921 s->flags= avctx->flags;
922 s->flags2= avctx->flags2;
923 s->max_b_frames= avctx->max_b_frames;
924 s->codec_id= avctx->codec->id;
925 s->luma_elim_threshold = avctx->luma_elim_threshold;
926 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927 s->strict_std_compliance= avctx->strict_std_compliance;
928 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930 s->mpeg_quant= avctx->mpeg_quant;
931 s->rtp_mode= !!avctx->rtp_payload_size;
932 s->intra_dc_precision= avctx->intra_dc_precision;
933 s->user_specified_pts = AV_NOPTS_VALUE;
934
935 if (s->gop_size <= 1) {
936 s->intra_only = 1;
937 s->gop_size = 12;
938 } else {
939 s->intra_only = 0;
940 }
941
942 s->me_method = avctx->me_method;
943
944 /* Fixed QSCALE */
945 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946
947 s->adaptive_quant= ( s->avctx->lumi_masking
948 || s->avctx->dark_masking
949 || s->avctx->temporal_cplx_masking
950 || s->avctx->spatial_cplx_masking
951 || s->avctx->p_masking
952 || s->avctx->border_masking
953 || (s->flags&CODEC_FLAG_QP_RD))
954 && !s->fixed_qscale;
955
956 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959
960 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
962 return -1;
963 }
964
965 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
967 }
968
969 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971 return -1;
972 }
973
974 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976 return -1;
977 }
978
979 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982
983 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
984 }
985
986 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989 return -1;
990 }
991
992 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
994 return -1;
995 }
996
997 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999 return -1;
1000 }
1001
1002 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004 return -1;
1005 }
1006
1007 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009 return -1;
1010 }
1011
1012 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014 return -1;
1015 }
1016
1017 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1018 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020 return -1;
1021 }
1022
1023 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1025 return -1;
1026 }
1027
1028 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030 return -1;
1031 }
1032
1033 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035 return -1;
1036 }
1037
1038 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040 return -1;
1041 }
1042
1043 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1044 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047 return -1;
1048 }
1049
1050 if(s->avctx->thread_count > 1)
1051 s->rtp_mode= 1;
1052
1053 if(!avctx->time_base.den || !avctx->time_base.num){
1054 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055 return -1;
1056 }
1057
1058 i= (INT_MAX/2+128)>>8;
1059 if(avctx->me_threshold >= i){
1060 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1061 return -1;
1062 }
1063 if(avctx->mb_threshold >= i){
1064 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1065 return -1;
1066 }
1067
1068 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1069 av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass");
1070 return -1;
1071 }
1072
1073 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1074 if(i > 1){
1075 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1076 avctx->time_base.den /= i;
1077 avctx->time_base.num /= i;
1078 // return -1;
1079 }
1080
1081 if(s->codec_id==CODEC_ID_MJPEG){
1082 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1083 s->inter_quant_bias= 0;
1084 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1085 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1086 s->inter_quant_bias= 0;
1087 }else{
1088 s->intra_quant_bias=0;
1089 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1090 }
1091
1092 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1093 s->intra_quant_bias= avctx->intra_quant_bias;
1094 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1095 s->inter_quant_bias= avctx->inter_quant_bias;
1096
1097 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1098
1099 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1100 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1101 return -1;
1102 }
1103 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1104
1105 switch(avctx->codec->id) {
1106 case CODEC_ID_MPEG1VIDEO:
1107 s->out_format = FMT_MPEG1;
1108 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1109 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1110 break;
1111 case CODEC_ID_MPEG2VIDEO:
1112 s->out_format = FMT_MPEG1;
1113 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1114 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1115 s->rtp_mode= 1;
1116 break;
1117 case CODEC_ID_LJPEG:
1118 case CODEC_ID_JPEGLS:
1119 case CODEC_ID_MJPEG:
1120 s->out_format = FMT_MJPEG;
1121 s->intra_only = 1; /* force intra only for jpeg */
1122 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1123 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1124 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1125 s->mjpeg_vsample[1] = 1;
1126 s->mjpeg_vsample[2] = 1;
1127 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1128 s->mjpeg_hsample[1] = 1;
1129 s->mjpeg_hsample[2] = 1;
1130 if (mjpeg_init(s) < 0)
1131 return -1;
1132 avctx->delay=0;
1133 s->low_delay=1;
1134 break;
1135 case CODEC_ID_H261:
1136 s->out_format = FMT_H261;
1137 avctx->delay=0;
1138 s->low_delay=1;
1139 break;
1140 case CODEC_ID_H263:
1141 if (h263_get_picture_format(s->width, s->height) == 7) {
1142 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1143 return -1;
1144 }
1145 s->out_format = FMT_H263;
1146 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1147 avctx->delay=0;
1148 s->low_delay=1;
1149 break;
1150 case CODEC_ID_H263P:
1151 s->out_format = FMT_H263;
1152 s->h263_plus = 1;
1153 /* Fx */
1154 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1155 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1156 s->modified_quant= s->h263_aic;
1157 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1158 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1159 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1160 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1161 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1162
1163 /* /Fx */
1164 /* These are just to be sure */
1165 avctx->delay=0;
1166 s->low_delay=1;
1167 break;
1168 case CODEC_ID_FLV1:
1169 s->out_format = FMT_H263;
1170 s->h263_flv = 2; /* format = 1; 11-bit codes */
1171 s->unrestricted_mv = 1;
1172 s->rtp_mode=0; /* don't allow GOB */
1173 avctx->delay=0;
1174 s->low_delay=1;
1175 break;
1176 case CODEC_ID_RV10:
1177 s->out_format = FMT_H263;
1178 avctx->delay=0;
1179 s->low_delay=1;
1180 break;
1181 case CODEC_ID_RV20:
1182 s->out_format = FMT_H263;
1183 avctx->delay=0;
1184 s->low_delay=1;
1185 s->modified_quant=1;
1186 s->h263_aic=1;
1187 s->h263_plus=1;
1188 s->loop_filter=1;
1189 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1190 break;
1191 case CODEC_ID_MPEG4:
1192 s->out_format = FMT_H263;
1193 s->h263_pred = 1;
1194 s->unrestricted_mv = 1;
1195 s->low_delay= s->max_b_frames ? 0 : 1;
1196 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1197 break;
1198 case CODEC_ID_MSMPEG4V1:
1199 s->out_format = FMT_H263;
1200 s->h263_msmpeg4 = 1;
1201 s->h263_pred = 1;
1202 s->unrestricted_mv = 1;
1203 s->msmpeg4_version= 1;
1204 avctx->delay=0;
1205 s->low_delay=1;
1206 break;
1207 case CODEC_ID_MSMPEG4V2:
1208 s->out_format = FMT_H263;
1209 s->h263_msmpeg4 = 1;
1210 s->h263_pred = 1;
1211 s->unrestricted_mv = 1;
1212 s->msmpeg4_version= 2;
1213 avctx->delay=0;
1214 s->low_delay=1;
1215 break;
1216 case CODEC_ID_MSMPEG4V3:
1217 s->out_format = FMT_H263;
1218 s->h263_msmpeg4 = 1;
1219 s->h263_pred = 1;
1220 s->unrestricted_mv = 1;
1221 s->msmpeg4_version= 3;
1222 s->flipflop_rounding=1;
1223 avctx->delay=0;
1224 s->low_delay=1;
1225 break;
1226 case CODEC_ID_WMV1:
1227 s->out_format = FMT_H263;
1228 s->h263_msmpeg4 = 1;
1229 s->h263_pred = 1;
1230 s->unrestricted_mv = 1;
1231 s->msmpeg4_version= 4;
1232 s->flipflop_rounding=1;
1233 avctx->delay=0;
1234 s->low_delay=1;
1235 break;
1236 case CODEC_ID_WMV2:
1237 s->out_format = FMT_H263;
1238 s->h263_msmpeg4 = 1;
1239 s->h263_pred = 1;
1240 s->unrestricted_mv = 1;
1241 s->msmpeg4_version= 5;
1242 s->flipflop_rounding=1;
1243 avctx->delay=0;
1244 s->low_delay=1;
1245 break;
1246 default:
1247 return -1;
1248 }
1249
1250 avctx->has_b_frames= !s->low_delay;
1251
1252 s->encoding = 1;
1253
1254 /* init */
1255 if (MPV_common_init(s) < 0)
1256 return -1;
1257
1258 if(s->modified_quant)
1259 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1260 s->progressive_frame=
1261 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1262 s->quant_precision=5;
1263
1264 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1265 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1266
1267 #ifdef CONFIG_H261_ENCODER
1268 if (s->out_format == FMT_H261)
1269 ff_h261_encode_init(s);
1270 #endif
1271 if (s->out_format == FMT_H263)
1272 h263_encode_init(s);
1273 if(s->msmpeg4_version)
1274 ff_msmpeg4_encode_init(s);
1275 if (s->out_format == FMT_MPEG1)
1276 ff_mpeg1_encode_init(s);
1277
1278 /* init q matrix */
1279 for(i=0;i<64;i++) {
1280 int j= s->dsp.idct_permutation[i];
1281 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1282 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1283 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1284 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1285 s->intra_matrix[j] =
1286 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1287 }else
1288 { /* mpeg1/2 */
1289 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1290 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1291 }
1292 if(s->avctx->intra_matrix)
1293 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1294 if(s->avctx->inter_matrix)
1295 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1296 }
1297
1298 /* precompute matrix */
1299 /* for mjpeg, we do include qscale in the matrix */
1300 if (s->out_format != FMT_MJPEG) {
1301 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1302 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1303 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1304 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1305 }
1306
1307 if(ff_rate_control_init(s) < 0)
1308 return -1;
1309
1310 return 0;
1311 }
1312
1313 int MPV_encode_end(AVCodecContext *avctx)
1314 {
1315 MpegEncContext *s = avctx->priv_data;
1316
1317 #ifdef STATS
1318 print_stats();
1319 #endif
1320
1321 ff_rate_control_uninit(s);
1322
1323 MPV_common_end(s);
1324 if (s->out_format == FMT_MJPEG)
1325 mjpeg_close(s);
1326
1327 av_freep(&avctx->extradata);
1328
1329 return 0;
1330 }
1331
1332 #endif //CONFIG_ENCODERS
1333
1334 void init_rl(RLTable *rl, int use_static)
1335 {
1336 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1337 uint8_t index_run[MAX_RUN+1];
1338 int last, run, level, start, end, i;
1339
1340 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1341 if(use_static && rl->max_level[0])
1342 return;
1343
1344 /* compute max_level[], max_run[] and index_run[] */
1345 for(last=0;last<2;last++) {
1346 if (last == 0) {
1347 start = 0;
1348 end = rl->last;
1349 } else {
1350 start = rl->last;
1351 end = rl->n;
1352 }
1353
1354 memset(max_level, 0, MAX_RUN + 1);
1355 memset(max_run, 0, MAX_LEVEL + 1);
1356 memset(index_run, rl->n, MAX_RUN + 1);
1357 for(i=start;i<end;i++) {
1358 run = rl->table_run[i];
1359 level = rl->table_level[i];
1360 if (index_run[run] == rl->n)
1361 index_run[run] = i;
1362 if (level > max_level[run])
1363 max_level[run] = level;
1364 if (run > max_run[level])
1365 max_run[level] = run;
1366 }
1367 if(use_static)
1368 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1369 else
1370 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1371 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1372 if(use_static)
1373 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1374 else
1375 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1376 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1377 if(use_static)
1378 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1379 else
1380 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1381 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1382 }
1383 }
1384
1385 /* draw the edges of width 'w' of an image of size width, height */
1386 //FIXME check that this is ok for mpeg4 interlaced
1387 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1388 {
1389 uint8_t *ptr, *last_line;
1390 int i;
1391
1392 last_line = buf + (height - 1) * wrap;
1393 for(i=0;i<w;i++) {
1394 /* top and bottom */
1395 memcpy(buf - (i + 1) * wrap, buf, width);
1396 memcpy(last_line + (i + 1) * wrap, last_line, width);
1397 }
1398 /* left and right */
1399 ptr = buf;
1400 for(i=0;i<height;i++) {
1401 memset(ptr - w, ptr[0], w);
1402 memset(ptr + width, ptr[width-1], w);
1403 ptr += wrap;
1404 }
1405 /* corners */
1406 for(i=0;i<w;i++) {
1407 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1408 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1409 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1410 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1411 }
1412 }
1413
1414 int ff_find_unused_picture(MpegEncContext *s, int shared){
1415 int i;
1416
1417 if(shared){
1418 for(i=0; i<MAX_PICTURE_COUNT; i++){
1419 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1420 }
1421 }else{
1422 for(i=0; i<MAX_PICTURE_COUNT; i++){
1423 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1424 }
1425 for(i=0; i<MAX_PICTURE_COUNT; i++){
1426 if(s->picture[i].data[0]==NULL) return i;
1427 }
1428 }
1429
1430 assert(0);
1431 return -1;
1432 }
1433
1434 static void update_noise_reduction(MpegEncContext *s){
1435 int intra, i;
1436
1437 for(intra=0; intra<2; intra++){
1438 if(s->dct_count[intra] > (1<<16)){
1439 for(i=0; i<64; i++){
1440 s->dct_error_sum[intra][i] >>=1;
1441 }
1442 s->dct_count[intra] >>= 1;
1443 }
1444
1445 for(i=0; i<64; i++){
1446 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);
1447 }
1448 }
1449 }
1450
1451 /**
1452 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1453 */
1454 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1455 {
1456 int i;
1457 AVFrame *pic;
1458 s->mb_skipped = 0;
1459
1460 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1461
1462 /* mark&release old frames */
1463 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1464 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1465
1466 /* release forgotten pictures */
1467 /* if(mpeg124/h263) */
1468 if(!s->encoding){
1469 for(i=0; i<MAX_PICTURE_COUNT; i++){
1470 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1471 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1472 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1473 }
1474 }
1475 }
1476 }
1477 alloc:
1478 if(!s->encoding){
1479 /* release non reference frames */
1480 for(i=0; i<MAX_PICTURE_COUNT; i++){
1481 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1482 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1483 }
1484 }
1485
1486 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1487 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1488 else{
1489 i= ff_find_unused_picture(s, 0);
1490 pic= (AVFrame*)&s->picture[i];
1491 }
1492
1493 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1494 && !s->dropable ? 3 : 0;
1495
1496 pic->coded_picture_number= s->coded_picture_number++;
1497
1498 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1499 return -1;
1500
1501 s->current_picture_ptr= (Picture*)pic;
1502 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1503 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1504 }
1505
1506 s->current_picture_ptr->pict_type= s->pict_type;
1507 // if(s->flags && CODEC_FLAG_QSCALE)
1508 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1509 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1510
1511 copy_picture(&s->current_picture, s->current_picture_ptr);
1512
1513 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1514 if (s->pict_type != B_TYPE) {
1515 s->last_picture_ptr= s->next_picture_ptr;
1516 if(!s->dropable)
1517 s->next_picture_ptr= s->current_picture_ptr;
1518 }
1519 /* 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,
1520 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1521 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1522 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1523 s->pict_type, s->dropable);*/
1524
1525 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1526 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1527
1528 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1529 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1530 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1531 goto alloc;
1532 }
1533
1534 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1535
1536 if(s->picture_structure!=PICT_FRAME){
1537 int i;
1538 for(i=0; i<4; i++){
1539 if(s->picture_structure == PICT_BOTTOM_FIELD){
1540 s->current_picture.data[i] += s->current_picture.linesize[i];
1541 }
1542 s->current_picture.linesize[i] *= 2;
1543 s->last_picture.linesize[i] *=2;
1544 s->next_picture.linesize[i] *=2;
1545 }
1546 }
1547 }
1548
1549 s->hurry_up= s->avctx->hurry_up;
1550 s->error_resilience= avctx->error_resilience;
1551
1552 /* set dequantizer, we can't do it during init as it might change for mpeg4
1553 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1554 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1555 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1556 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1557 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1558 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1559 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1560 }else{
1561 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1562 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1563 }
1564
1565 if(s->dct_error_sum){
1566 assert(s->avctx->noise_reduction && s->encoding);
1567
1568 update_noise_reduction(s);
1569 }
1570
1571 #ifdef HAVE_XVMC
1572 if(s->avctx->xvmc_acceleration)
1573 return XVMC_field_start(s, avctx);
1574 #endif
1575 return 0;
1576 }
1577
1578 /* generic function for encode/decode called after a frame has been coded/decoded */
1579 void MPV_frame_end(MpegEncContext *s)
1580 {
1581 int i;
1582 /* draw edge for correct motion prediction if outside */
1583 #ifdef HAVE_XVMC
1584 //just to make sure that all data is rendered.
1585 if(s->avctx->xvmc_acceleration){
1586 XVMC_field_end(s);
1587 }else
1588 #endif
1589 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1590 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1591 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1592 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1593 }
1594 emms_c();
1595
1596 s->last_pict_type = s->pict_type;
1597 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1598 if(s->pict_type!=B_TYPE){
1599 s->last_non_b_pict_type= s->pict_type;
1600 }
1601 #if 0
1602 /* copy back current_picture variables */
1603 for(i=0; i<MAX_PICTURE_COUNT; i++){
1604 if(s->picture[i].data[0] == s->current_picture.data[0]){
1605 s->picture[i]= s->current_picture;
1606 break;
1607 }
1608 }
1609 assert(i<MAX_PICTURE_COUNT);
1610 #endif
1611
1612 if(s->encoding){
1613 /* release non-reference frames */
1614 for(i=0; i<MAX_PICTURE_COUNT; i++){
1615 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1616 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1617 }
1618 }
1619 }
1620 // clear copies, to avoid confusion
1621 #if 0
1622 memset(&s->last_picture, 0, sizeof(Picture));
1623 memset(&s->next_picture, 0, sizeof(Picture));
1624 memset(&s->current_picture, 0, sizeof(Picture));
1625 #endif
1626 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1627 }
1628
1629 /**
1630 * draws an line from (ex, ey) -> (sx, sy).
1631 * @param w width of the image
1632 * @param h height of the image
1633 * @param stride stride/linesize of the image
1634 * @param color color of the arrow
1635 */
1636 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1637 int t, x, y, fr, f;
1638
1639 sx= clip(sx, 0, w-1);
1640 sy= clip(sy, 0, h-1);
1641 ex= clip(ex, 0, w-1);
1642 ey= clip(ey, 0, h-1);
1643
1644 buf[sy*stride + sx]+= color;
1645
1646 if(ABS(ex - sx) > ABS(ey - sy)){
1647 if(sx > ex){
1648 t=sx; sx=ex; ex=t;
1649 t=sy; sy=ey; ey=t;
1650 }
1651 buf+= sx + sy*stride;
1652 ex-= sx;
1653 f= ((ey-sy)<<16)/ex;
1654 for(x= 0; x <= ex; x++){
1655 y = (x*f)>>16;
1656 fr= (x*f)&0xFFFF;
1657 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1658 buf[(y+1)*stride + x]+= (color* fr )>>16;
1659 }
1660 }else{
1661 if(sy > ey){
1662 t=sx; sx=ex; ex=t;
1663 t=sy; sy=ey; ey=t;
1664 }
1665 buf+= sx + sy*stride;
1666 ey-= sy;
1667 if(ey) f= ((ex-sx)<<16)/ey;
1668 else f= 0;
1669 for(y= 0; y <= ey; y++){
1670 x = (y*f)>>16;
1671 fr= (y*f)&0xFFFF;
1672 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1673 buf[y*stride + x+1]+= (color* fr )>>16;;
1674 }
1675 }
1676 }
1677
1678 /**
1679 * draws an arrow from (ex, ey) -> (sx, sy).
1680 * @param w width of the image
1681 * @param h height of the image
1682 * @param stride stride/linesize of the image
1683 * @param color color of the arrow
1684 */
1685 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1686 int dx,dy;
1687
1688 sx= clip(sx, -100, w+100);
1689 sy= clip(sy, -100, h+100);
1690 ex= clip(ex, -100, w+100);
1691 ey= clip(ey, -100, h+100);
1692
1693 dx= ex - sx;
1694 dy= ey - sy;
1695
1696 if(dx*dx + dy*dy > 3*3){
1697 int rx= dx + dy;
1698 int ry= -dx + dy;
1699 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1700
1701 //FIXME subpixel accuracy
1702 rx= ROUNDED_DIV(rx*3<<4, length);
1703 ry= ROUNDED_DIV(ry*3<<4, length);
1704
1705 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1706 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1707 }
1708 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1709 }
1710
1711 /**
1712 * prints debuging info for the given picture.
1713 */
1714 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1715
1716 if(!pict || !pict->mb_type) return;
1717
1718 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1719 int x,y;
1720
1721 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1722 switch (pict->pict_type) {
1723 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1724 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1725 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1726 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1727 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1728 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1729 }
1730 for(y=0; y<s->mb_height; y++){
1731 for(x=0; x<s->mb_width; x++){
1732 if(s->avctx->debug&FF_DEBUG_SKIP){
1733 int count= s->mbskip_table[x + y*s->mb_stride];
1734 if(count>9) count=9;
1735 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1736 }
1737 if(s->avctx->debug&FF_DEBUG_QP){
1738 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1739 }
1740 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1741 int mb_type= pict->mb_type[x + y*s->mb_stride];
1742 //Type & MV direction
1743 if(IS_PCM(mb_type))
1744 av_log(s->avctx, AV_LOG_DEBUG, "P");
1745 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1746 av_log(s->avctx, AV_LOG_DEBUG, "A");
1747 else if(IS_INTRA4x4(mb_type))
1748 av_log(s->avctx, AV_LOG_DEBUG, "i");
1749 else if(IS_INTRA16x16(mb_type))
1750 av_log(s->avctx, AV_LOG_DEBUG, "I");
1751 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1752 av_log(s->avctx, AV_LOG_DEBUG, "d");
1753 else if(IS_DIRECT(mb_type))
1754 av_log(s->avctx, AV_LOG_DEBUG, "D");
1755 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1756 av_log(s->avctx, AV_LOG_DEBUG, "g");
1757 else if(IS_GMC(mb_type))
1758 av_log(s->avctx, AV_LOG_DEBUG, "G");
1759 else if(IS_SKIP(mb_type))
1760 av_log(s->avctx, AV_LOG_DEBUG, "S");
1761 else if(!USES_LIST(mb_type, 1))
1762 av_log(s->avctx, AV_LOG_DEBUG, ">");
1763 else if(!USES_LIST(mb_type, 0))
1764 av_log(s->avctx, AV_LOG_DEBUG, "<");
1765 else{
1766 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1767 av_log(s->avctx, AV_LOG_DEBUG, "X");
1768 }
1769
1770 //segmentation
1771 if(IS_8X8(mb_type))
1772 av_log(s->avctx, AV_LOG_DEBUG, "+");
1773 else if(IS_16X8(mb_type))
1774 av_log(s->avctx, AV_LOG_DEBUG, "-");
1775 else if(IS_8X16(mb_type))
1776 av_log(s->avctx, AV_LOG_DEBUG, "|");
1777 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1778 av_log(s->avctx, AV_LOG_DEBUG, " ");
1779 else
1780 av_log(s->avctx, AV_LOG_DEBUG, "?");
1781
1782
1783 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1784 av_log(s->avctx, AV_LOG_DEBUG, "=");
1785 else
1786 av_log(s->avctx, AV_LOG_DEBUG, " ");
1787 }
1788 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1789 }
1790 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1791 }
1792 }
1793
1794 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1795 const int shift= 1 + s->quarter_sample;
1796 int mb_y;
1797 uint8_t *ptr;
1798 int i;
1799 int h_chroma_shift, v_chroma_shift;
1800 const int width = s->avctx->width;
1801 const int height= s->avctx->height;
1802 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1803 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1804 s->low_delay=0; //needed to see the vectors without trashing the buffers
1805
1806 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1807 for(i=0; i<3; i++){
1808 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1809 pict->data[i]= s->visualization_buffer[i];
1810 }
1811 pict->type= FF_BUFFER_TYPE_COPY;
1812 ptr= pict->data[0];
1813
1814 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1815 int mb_x;
1816 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1817 const int mb_index= mb_x + mb_y*s->mb_stride;
1818 if((s->avctx->debug_mv) && pict->motion_val){
1819 int type;
1820 for(type=0; type<3; type++){
1821 int direction = 0;
1822 switch (type) {
1823 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1824 continue;
1825 direction = 0;
1826 break;
1827 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1828 continue;
1829 direction = 0;
1830 break;
1831 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1832 continue;
1833 direction = 1;
1834 break;
1835 }
1836 if(!USES_LIST(pict->mb_type[mb_index], direction))
1837 continue;
1838
1839 if(IS_8X8(pict->mb_type[mb_index])){
1840 int i;
1841 for(i=0; i<4; i++){
1842 int sx= mb_x*16 + 4 + 8*(i&1);
1843 int sy= mb_y*16 + 4 + 8*(i>>1);
1844 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1845 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1846 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1847 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1848 }
1849 }else if(IS_16X8(pict->mb_type[mb_index])){
1850 int i;
1851 for(i=0; i<2; i++){
1852 int sx=mb_x*16 + 8;
1853 int sy=mb_y*16 + 4 + 8*i;
1854 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1855 int mx=(pict->motion_val[direction][xy][0]>>shift);
1856 int my=(pict->motion_val[direction][xy][1]>>shift);
1857
1858 if(IS_INTERLACED(pict->mb_type[mb_index]))
1859 my*=2;
1860
1861 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1862 }
1863 }else if(IS_8X16(pict->mb_type[mb_index])){
1864 int i;
1865 for(i=0; i<2; i++){
1866 int sx=mb_x*16 + 4 + 8*i;
1867 int sy=mb_y*16 + 8;
1868 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1869 int mx=(pict->motion_val[direction][xy][0]>>shift);
1870 int my=(pict->motion_val[direction][xy][1]>>shift);
1871
1872 if(IS_INTERLACED(pict->mb_type[mb_index]))
1873 my*=2;
1874
1875 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1876 }
1877 }else{
1878 int sx= mb_x*16 + 8;
1879 int sy= mb_y*16 + 8;
1880 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1881 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1882 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1883 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1884 }
1885 }
1886 }
1887 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1888 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1889 int y;
1890 for(y=0; y<8; y++){
1891 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1892 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1893 }
1894 }
1895 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1896 int mb_type= pict->mb_type[mb_index];
1897 uint64_t u,v;
1898 int y;
1899 #define COLOR(theta, r)\
1900 u= (int)(128 + r*cos(theta*3.141592/180));\
1901 v= (int)(128 + r*sin(theta*3.141592/180));
1902
1903
1904 u=v=128;
1905 if(IS_PCM(mb_type)){
1906 COLOR(120,48)
1907 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1908 COLOR(30,48)
1909 }else if(IS_INTRA4x4(mb_type)){
1910 COLOR(90,48)
1911 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1912 // COLOR(120,48)
1913 }else if(IS_DIRECT(mb_type)){
1914 COLOR(150,48)
1915 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1916 COLOR(170,48)
1917 }else if(IS_GMC(mb_type)){
1918 COLOR(190,48)
1919 }else if(IS_SKIP(mb_type)){
1920 // COLOR(180,48)
1921 }else if(!USES_LIST(mb_type, 1)){
1922 COLOR(240,48)
1923 }else if(!USES_LIST(mb_type, 0)){
1924 COLOR(0,48)
1925 }else{
1926 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1927 COLOR(300,48)
1928 }
1929
1930 u*= 0x0101010101010101ULL;
1931 v*= 0x0101010101010101ULL;
1932 for(y=0; y<8; y++){
1933 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1934 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1935 }
1936
1937 //segmentation
1938 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1939 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1940 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1941 }
1942 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1943 for(y=0; y<16; y++)
1944 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1945 }
1946 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1947 int dm= 1 << (mv_sample_log2-2);
1948 for(i=0; i<4; i++){
1949 int sx= mb_x*16 + 8*(i&1);
1950 int sy= mb_y*16 + 8*(i>>1);
1951 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1952 //FIXME bidir
1953 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1954 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1955 for(y=0; y<8; y++)
1956 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1957 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1958 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1959 }
1960 }
1961
1962 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1963 // hmm
1964 }
1965 }
1966 s->mbskip_table[mb_index]=0;
1967 }
1968 }
1969 }
1970 }
1971
1972 #ifdef CONFIG_ENCODERS
1973
1974 static int get_sae(uint8_t *src, int ref, int stride){
1975 int x,y;
1976 int acc=0;
1977
1978 for(y=0; y<16; y++){
1979 for(x=0; x<16; x++){
1980 acc+= ABS(src[x+y*stride] - ref);
1981 }
1982 }
1983
1984 return acc;
1985 }
1986
1987 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1988 int x, y, w, h;
1989 int acc=0;
1990
1991 w= s->width &~15;
1992 h= s->height&~15;
1993
1994 for(y=0; y<h; y+=16){
1995 for(x=0; x<w; x+=16){
1996 int offset= x + y*stride;
1997 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1998 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1999 int sae = get_sae(src + offset, mean, stride);
2000
2001 acc+= sae + 500 < sad;
2002 }
2003 }
2004 return acc;
2005 }
2006
2007
2008 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2009 AVFrame *pic=NULL;
2010 int64_t pts;
2011 int i;
2012 const int encoding_delay= s->max_b_frames;
2013 int direct=1;
2014
2015 if(pic_arg){
2016 pts= pic_arg->pts;
2017 pic_arg->display_picture_number= s->input_picture_number++;
2018
2019 if(pts != AV_NOPTS_VALUE){
2020 if(s->user_specified_pts != AV_NOPTS_VALUE){
2021 int64_t time= pts;
2022 int64_t last= s->user_specified_pts;
2023
2024 if(time <= last){
2025 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2026 return -1;
2027 }
2028 }
2029 s->user_specified_pts= pts;
2030 }else{
2031 if(s->user_specified_pts != AV_NOPTS_VALUE){
2032 s->user_specified_pts=
2033 pts= s->user_specified_pts + 1;
2034 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2035 }else{
2036 pts= pic_arg->display_picture_number;
2037 }
2038 }
2039 }
2040
2041 if(pic_arg){
2042 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2043 if(pic_arg->linesize[0] != s->linesize) direct=0;
2044 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2045 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2046
2047 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2048
2049 if(direct){
2050 i= ff_find_unused_picture(s, 1);
2051
2052 pic= (AVFrame*)&s->picture[i];
2053 pic->reference= 3;
2054
2055 for(i=0; i<4; i++){
2056 pic->data[i]= pic_arg->data[i];
2057 pic->linesize[i]= pic_arg->linesize[i];
2058 }
2059 alloc_picture(s, (Picture*)pic, 1);
2060 }else{
2061 int offset= 16;
2062 i= ff_find_unused_picture(s, 0);
2063
2064 pic= (AVFrame*)&s->picture[i];
2065 pic->reference= 3;
2066
2067 alloc_picture(s, (Picture*)pic, 0);
2068
2069 if( pic->data[0] + offset == pic_arg->data[0]
2070 && pic->data[1] + offset == pic_arg->data[1]
2071 && pic->data[2] + offset == pic_arg->data[2]){
2072 // empty
2073 }else{
2074 int h_chroma_shift, v_chroma_shift;
2075 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2076
2077 for(i=0; i<3; i++){
2078 int src_stride= pic_arg->linesize[i];
2079 int dst_stride= i ? s->uvlinesize : s->linesize;
2080 int h_shift= i ? h_chroma_shift : 0;
2081 int v_shift= i ? v_chroma_shift : 0;
2082 int w= s->width >>h_shift;
2083 int h= s->height>>v_shift;
2084 uint8_t *src= pic_arg->data[i];
2085 uint8_t *dst= pic->data[i] + offset;
2086
2087 if(src_stride==dst_stride)
2088 memcpy(dst, src, src_stride*h);
2089 else{
2090 while(h--){
2091 memcpy(dst, src, w);
2092 dst += dst_stride;
2093 src += src_stride;
2094 }
2095 }
2096 }
2097 }
2098 }
2099 copy_picture_attributes(s, pic, pic_arg);
2100 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2101 }
2102
2103 /* shift buffer entries */
2104 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2105 s->input_picture[i-1]= s->input_picture[i];
2106
2107 s->input_picture[encoding_delay]= (Picture*)pic;
2108
2109 return 0;
2110 }
2111
2112 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2113 int x, y, plane;
2114 int score=0;
2115 int64_t score64=0;
2116
2117 for(plane=0; plane<3; plane++){
2118 const int stride= p->linesize[plane];
2119 const int bw= plane ? 1 : 2;
2120 for(y=0; y<s->mb_height*bw; y++){
2121 for(x=0; x<s->mb_width*bw; x++){
2122 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2123 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);
2124
2125 switch(s->avctx->frame_skip_exp){
2126 case 0: score= FFMAX(score, v); break;
2127 case 1: score+= ABS(v);break;
2128 case 2: score+= v*v;break;
2129 case 3: score64+= ABS(v*v*(int64_t)v);break;
2130 case 4: score64+= v*v*(int64_t)(v*v);break;
2131 }
2132 }
2133 }
2134 }
2135
2136 if(score) score64= score;
2137
2138 if(score64 < s->avctx->frame_skip_threshold)
2139 return 1;
2140 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2141 return 1;
2142 return 0;
2143 }
2144
2145 static int estimate_best_b_count(MpegEncContext *s){
2146 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2147 AVCodecContext *c= avcodec_alloc_context();
2148 AVFrame input[FF_MAX_B_FRAMES+2];
2149 const int scale= s->avctx->brd_scale;
2150 int i, j, out_size;
2151 int outbuf_size= s->width * s->height; //FIXME
2152 uint8_t *outbuf= av_malloc(outbuf_size);
2153 ImgReSampleContext *resample;
2154 int64_t best_rd= INT64_MAX;
2155 int best_b_count= -1;
2156 const int lambda2= s->lambda2;
2157
2158 c->width = s->width >> scale;
2159 c->height= s->height>> scale;
2160 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2161 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2162 c->mb_decision= s->avctx->mb_decision;
2163 c->me_cmp= s->avctx->me_cmp;
2164 c->mb_cmp= s->avctx->mb_cmp;
2165 c->me_sub_cmp= s->avctx->me_sub_cmp;
2166 c->pix_fmt = PIX_FMT_YUV420P;
2167 c->time_base= s->avctx->time_base;
2168 c->max_b_frames= s->max_b_frames;
2169
2170 if (avcodec_open(c, codec) < 0)
2171 return -1;
2172
2173 resample= img_resample_init(c->width, c->height, s->width, s->height); //FIXME use sws
2174
2175 for(i=0; i<s->max_b_frames+2; i++){
2176 int ysize= c->width*c->height;
2177 int csize= (c->width/2)*(c->height/2);
2178
2179 avcodec_get_frame_defaults(&input[i]);
2180 input[i].data[0]= av_malloc(ysize + 2*csize);
2181 input[i].data[1]= input[i].data[0] + ysize;
2182 input[i].data[2]= input[i].data[1] + csize;
2183 input[i].linesize[0]= c->width;
2184 input[i].linesize[1]=
2185 input[i].linesize[2]= c->width/2;
2186
2187 if(!i || s->input_picture[i-1])
2188 img_resample(resample, &input[i], i ? s->input_picture[i-1] : s->next_picture_ptr);
2189 }
2190
2191 for(j=0; j<s->max_b_frames+1; j++){
2192 int64_t rd=0;
2193
2194 if(!s->input_picture[j])
2195 break;
2196
2197 c->error[0]= c->error[1]= c->error[2]= 0;
2198
2199 input[0].pict_type= I_TYPE;
2200 input[0].quality= 2 * FF_QP2LAMBDA;
2201 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2202 rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2203
2204 for(i=0; i<s->max_b_frames+1; i++){
2205 int is_p= i % (j+1) == j || i==s->max_b_frames;
2206
2207 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2208 input[i+1].quality= s->last_lambda_for[input[i+1].pict_type];
2209 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2210 rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2211 }
2212
2213 /* get the delayed frames */
2214 while(out_size){
2215 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2216 rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2217 }
2218
2219 rd += c->error[0] + c->error[1] + c->error[2];
2220
2221 if(rd < best_rd){
2222 best_rd= rd;
2223 best_b_count= j;
2224 }
2225 }
2226
2227 av_freep(&outbuf);
2228 avcodec_close(c);
2229 av_freep(&c);
2230 img_resample_close(resample);
2231
2232 for(i=0; i<s->max_b_frames+2; i++){
2233 av_freep(&input[i].data[0]);
2234 }
2235
2236 return best_b_count;
2237 }
2238
2239 static void select_input_picture(MpegEncContext *s){
2240 int i;
2241
2242 for(i=1; i<MAX_PICTURE_COUNT; i++)
2243 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2244 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2245
2246 /* set next picture type & ordering */
2247 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2248 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2249 s->reordered_input_picture[0]= s->input_picture[0];
2250 s->reordered_input_picture[0]->pict_type= I_TYPE;
2251 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2252 }else{
2253 int b_frames;
2254
2255 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2256 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2257 //FIXME check that te gop check above is +-1 correct
2258 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2259
2260 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2261 for(i=0; i<4; i++)
2262 s->input_picture[0]->data[i]= NULL;
2263 s->input_picture[0]->type= 0;
2264 }else{
2265 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2266 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2267
2268 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2269 }
2270
2271 emms_c();
2272 ff_vbv_update(s, 0);
2273
2274 goto no_output_pic;
2275 }
2276 }
2277
2278 if(s->flags&CODEC_FLAG_PASS2){
2279 for(i=0; i<s->max_b_frames+1; i++){
2280 int pict_num= s->input_picture[0]->display_picture_number + i;
2281
2282 if(pict_num >= s->rc_context.num_entries)
2283 break;
2284 if(!s->input_picture[i]){
2285 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2286 break;
2287 }
2288
2289 s->input_picture[i]->pict_type=
2290 s->rc_context.entry[pict_num].new_pict_type;
2291 }
2292 }
2293
2294 if(s->avctx->b_frame_strategy==0){
2295 b_frames= s->max_b_frames;
2296 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2297 }else if(s->avctx->b_frame_strategy==1){
2298 for(i=1; i<s->max_b_frames+1; i++){
2299 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2300 s->input_picture[i]->b_frame_score=
2301 get_intra_count(s, s->input_picture[i ]->data[0],
2302 s->input_picture[i-1]->data[0], s->linesize) + 1;
2303 }
2304 }
2305 for(i=0; i<s->max_b_frames+1; i++){
2306 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2307 }
2308
2309 b_frames= FFMAX(0, i-1);
2310
2311 /* reset scores */
2312 for(i=0; i<b_frames+1; i++){
2313 s->input_picture[i]->b_frame_score=0;
2314 }
2315 }else if(s->avctx->b_frame_strategy==2){
2316 b_frames= estimate_best_b_count(s);
2317 }else{
2318 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2319 b_frames=0;
2320 }
2321
2322 emms_c();
2323 //static int b_count=0;
2324 //b_count+= b_frames;
2325 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2326
2327 for(i= b_frames - 1; i>=0; i--){
2328 int type= s->input_picture[i]->pict_type;
2329 if(type && type != B_TYPE)
2330 b_frames= i;
2331 }
2332 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2333 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2334 }
2335
2336 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2337 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2338 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2339 }else{
2340 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2341 b_frames=0;
2342 s->input_picture[b_frames]->pict_type= I_TYPE;
2343 }
2344 }
2345
2346 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2347 && b_frames
2348 && s->input_picture[b_frames]->pict_type== I_TYPE)
2349 b_frames--;
2350
2351 s->reordered_input_picture[0]= s->input_picture[b_frames];
2352 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2353 s->reordered_input_picture[0]->pict_type= P_TYPE;
2354 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2355 for(i=0; i<b_frames; i++){
2356 s->reordered_input_picture[i+1]= s->input_picture[i];
2357 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2358 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2359 }
2360 }
2361 }
2362 no_output_pic:
2363 if(s->reordered_input_picture[0]){
2364 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2365
2366 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2367
2368 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2369 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2370
2371 int i= ff_find_unused_picture(s, 0);
2372 Picture *pic= &s->picture[i];
2373
2374 /* mark us unused / free shared pic */
2375 for(i=0; i<4; i++)
2376 s->reordered_input_picture[0]->data[i]= NULL;
2377 s->reordered_input_picture[0]->type= 0;
2378
2379 pic->reference = s->reordered_input_picture[0]->reference;
2380
2381 alloc_picture(s, pic, 0);
2382
2383 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2384
2385 s->current_picture_ptr= pic;
2386 }else{
2387 // input is not a shared pix -> reuse buffer for current_pix
2388
2389 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2390 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2391
2392 s->current_picture_ptr= s->reordered_input_picture[0];
2393 for(i=0; i<4; i++){
2394 s->new_picture.data[i]+=16;
2395 }
2396 }
2397 copy_picture(&s->current_picture, s->current_picture_ptr);
2398
2399 s->picture_number= s->new_picture.display_picture_number;
2400 //printf("dpn:%d\n", s->picture_number);
2401 }else{
2402 memset(&s->new_picture, 0, sizeof(Picture));
2403 }
2404 }
2405
2406 int MPV_encode_picture(AVCodecContext *avctx,
2407 unsigned char *buf, int buf_size, void *data)
2408 {
2409 MpegEncContext *s = avctx->priv_data;
2410 AVFrame *pic_arg = data;
2411 int i, stuffing_count;
2412
2413 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2414 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2415 return -1;
2416 }
2417
2418 for(i=0; i<avctx->thread_count; i++){
2419 int start_y= s->thread_context[i]->start_mb_y;
2420 int end_y= s->thread_context[i]-> end_mb_y;
2421 int h= s->mb_height;
2422 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2423 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2424
2425 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2426 }
2427
2428 s->picture_in_gop_number++;
2429
2430 if(load_input_picture(s, pic_arg) < 0)
2431 return -1;
2432
2433 select_input_picture(s);
2434
2435 /* output? */
2436 if(s->new_picture.data[0]){
2437 s->pict_type= s->new_picture.pict_type;
2438 //emms_c();
2439 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2440 MPV_frame_start(s, avctx);
2441
2442 encode_picture(s, s->picture_number);
2443
2444 avctx->real_pict_num = s->picture_number;
2445 avctx->header_bits = s->header_bits;
2446 avctx->mv_bits = s->mv_bits;
2447 avctx->misc_bits = s->misc_bits;
2448 avctx->i_tex_bits = s->i_tex_bits;
2449 avctx->p_tex_bits = s->p_tex_bits;
2450 avctx->i_count = s->i_count;
2451 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2452 avctx->skip_count = s->skip_count;
2453
2454 MPV_frame_end(s);
2455
2456 if (s->out_format == FMT_MJPEG)
2457 mjpeg_picture_trailer(s);
2458
2459 if(s->flags&CODEC_FLAG_PASS1)
2460 ff_write_pass1_stats(s);
2461
2462 for(i=0; i<4; i++){
2463 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2464 avctx->error[i] += s->current_picture_ptr->error[i];
2465 }
2466
2467 if(s->flags&CODEC_FLAG_PASS1)
2468 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2469 flush_put_bits(&s->pb);
2470 s->frame_bits = put_bits_count(&s->pb);
2471
2472 stuffing_count= ff_vbv_update(s, s->frame_bits);
2473 if(stuffing_count){
2474 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2475 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2476 return -1;
2477 }
2478
2479 switch(s->codec_id){
2480 case CODEC_ID_MPEG1VIDEO:
2481 case CODEC_ID_MPEG2VIDEO:
2482 while(stuffing_count--){
2483 put_bits(&s->pb, 8, 0);
2484 }
2485 break;
2486 case CODEC_ID_MPEG4:
2487 put_bits(&s->pb, 16, 0);
2488 put_bits(&s->pb, 16, 0x1C3);
2489 stuffing_count -= 4;
2490 while(stuffing_count--){
2491 put_bits(&s->pb, 8, 0xFF);
2492 }
2493 break;
2494 default:
2495 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2496 }
2497 flush_put_bits(&s->pb);
2498 s->frame_bits = put_bits_count(&s->pb);
2499 }
2500
2501 /* update mpeg1/2 vbv_delay for CBR */
2502 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2503 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2504 int vbv_delay;
2505
2506 assert(s->repeat_first_field==0);
2507
2508 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2509 assert(vbv_delay < 0xFFFF);
2510
2511 s->vbv_delay_ptr[0] &= 0xF8;
2512 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2513 s->vbv_delay_ptr[1] = vbv_delay>>5;
2514 s->vbv_delay_ptr[2] &= 0x07;
2515 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2516 }
2517 s->total_bits += s->frame_bits;
2518 avctx->frame_bits = s->frame_bits;
2519 }else{
2520 assert((pbBufPtr(&s->pb) == s->pb.buf));
2521 s->frame_bits=0;
2522 }
2523 assert((s->frame_bits&7)==0);
2524
2525 return s->frame_bits/8;
2526 }
2527
2528 #endif //CONFIG_ENCODERS
2529
2530 static inline void gmc1_motion(MpegEncContext *s,
2531 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2532 uint8_t **ref_picture)
2533 {
2534 uint8_t *ptr;
2535 int offset, src_x, src_y, linesize, uvlinesize;
2536 int motion_x, motion_y;
2537 int emu=0;
2538
2539 motion_x= s->sprite_offset[0][0];
2540 motion_y= s->sprite_offset[0][1];
2541 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2542 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2543 motion_x<<=(3-s->sprite_warping_accuracy);
2544 motion_y<<=(3-s->sprite_warping_accuracy);
2545 src_x = clip(src_x, -16, s->width);
2546 if (src_x == s->width)
2547 motion_x =0;
2548 src_y = clip(src_y, -16, s->height);
2549 if (src_y == s->height)
2550 motion_y =0;
2551
2552 linesize = s->linesize;
2553 uvlinesize = s->uvlinesize;
2554
2555 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2556
2557 if(s->flags&CODEC_FLAG_EMU_EDGE){
2558 if( (unsigned)src_x >= s->h_edge_pos - 17
2559 || (unsigned)src_y >= s->v_edge_pos - 17){
2560 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2561 ptr= s->edge_emu_buffer;
2562 }
2563 }
2564
2565 if((motion_x|motion_y)&7){
2566 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2567 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2568 }else{
2569 int dxy;
2570
2571 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2572 if (s->no_rounding){
2573 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2574 }else{
2575 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2576 }
2577 }
2578
2579 if(s->flags&CODEC_FLAG_GRAY) return;
2580
2581 motion_x= s->sprite_offset[1][0];
2582 motion_y= s->sprite_offset[1][1];
2583 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2584 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2585 motion_x<<=(3-s->sprite_warping_accuracy);
2586 motion_y<<=(3-s->sprite_warping_accuracy);
2587 src_x = clip(src_x, -8, s->width>>1);
2588 if (src_x == s->width>>1)
2589 motion_x =0;
2590 src_y = clip(src_y, -8, s->height>>1);
2591 if (src_y == s->height>>1)
2592 motion_y =0;
2593
2594 offset = (src_y * uvlinesize) + src_x;
2595 ptr = ref_picture[1] + offset;
2596 if(s->flags&CODEC_FLAG_EMU_EDGE){
2597 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2598 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2599 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);
2600 ptr= s->edge_emu_buffer;
2601 emu=1;
2602 }
2603 }
2604 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2605
2606 ptr = ref_picture[2] + offset;
2607 if(emu){
2608 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);
2609 ptr= s->edge_emu_buffer;
2610 }
2611 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2612
2613 return;
2614 }
2615
2616 static inline void gmc_motion(MpegEncContext *s,
2617 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2618 uint8_t **ref_picture)
2619 {
2620 uint8_t *ptr;
2621 int linesize, uvlinesize;
2622 const int a= s->sprite_warping_accuracy;
2623 int ox, oy;
2624
2625 linesize = s->linesize;
2626 uvlinesize = s->uvlinesize;
2627
2628 ptr = ref_picture[0];
2629
2630 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2631 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2632
2633 s->dsp.gmc(dest_y, ptr, linesize, 16,
2634 ox,
2635 oy,
2636 s->sprite_delta[0][0], s->sprite_delta[0][1],
2637 s->sprite_delta[1][0], s->sprite_delta[1][1],
2638 a+1, (1<<(2*a+1)) - s->no_rounding,
2639 s->h_edge_pos, s->v_edge_pos);
2640 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2641 ox + s->sprite_delta[0][0]*8,
2642 oy + s->sprite_delta[1][0]*8,
2643 s->sprite_delta[0][0], s->sprite_delta[0][1],
2644 s->sprite_delta[1][0], s->sprite_delta[1][1],
2645 a+1, (1<<(2*a+1)) - s->no_rounding,
2646 s->h_edge_pos, s->v_edge_pos);
2647
2648 if(s->flags&CODEC_FLAG_GRAY) return;
2649
2650 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2651 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2652
2653 ptr = ref_picture[1];
2654 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2655 ox,
2656 oy,
2657 s->sprite_delta[0][0], s->sprite_delta[0][1],
2658 s->sprite_delta[1][0], s->sprite_delta[1][1],
2659 a+1, (1<<(2*a+1)) - s->no_rounding,
2660 s->h_edge_pos>>1, s->v_edge_pos>>1);
2661
2662 ptr = ref_picture[2];
2663 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2664 ox,
2665 oy,
2666 s->sprite_delta[0][0], s->sprite_delta[0][1],
2667 s->sprite_delta[1][0], s->sprite_delta[1][1],
2668 a+1, (1<<(2*a+1)) - s->no_rounding,
2669 s->h_edge_pos>>1, s->v_edge_pos>>1);
2670 }
2671
2672 /**
2673 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2674 * @param buf destination buffer
2675 * @param src source buffer
2676 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2677 * @param block_w width of block
2678 * @param block_h height of block
2679 * @param src_x x coordinate of the top left sample of the block in the source buffer
2680 * @param src_y y coordinate of the top left sample of the block in the source buffer
2681 * @param w width of the source buffer
2682 * @param h height of the source buffer
2683 */
2684 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2685 int src_x, int src_y, int w, int h){
2686 int x, y;
2687 int start_y, start_x, end_y, end_x;
2688
2689 if(src_y>= h){
2690 src+= (h-1-src_y)*linesize;
2691 src_y=h-1;
2692 }else if(src_y<=-block_h){
2693 src+= (1-block_h-src_y)*linesize;
2694 src_y=1-block_h;
2695 }
2696 if(src_x>= w){
2697 src+= (w-1-src_x);
2698 src_x=w-1;
2699 }else if(src_x<=-block_w){
2700 src+= (1-block_w-src_x);
2701 src_x=1-block_w;
2702 }
2703
2704 start_y= FFMAX(0, -src_y);
2705 start_x= FFMAX(0, -src_x);
2706 end_y= FFMIN(block_h, h-src_y);
2707 end_x= FFMIN(block_w, w-src_x);
2708
2709 // copy existing part
2710 for(y=start_y; y<end_y; y++){
2711 for(x=start_x; x<end_x; x++){
2712 buf[x + y*linesize]= src[x + y*linesize];
2713 }
2714 }
2715
2716 //top
2717 for(y=0; y<start_y; y++){
2718 for(x=start_x; x<end_x; x++){
2719 buf[x + y*linesize]= buf[x + start_y*linesize];
2720 }
2721 }
2722
2723 //bottom
2724 for(y=end_y; y<block_h; y++){
2725 for(x=start_x; x<end_x; x++){
2726 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2727 }
2728 }
2729
2730 for(y=0; y<block_h; y++){
2731 //left
2732 for(x=0; x<start_x; x++){
2733 buf[x + y*linesize]= buf[start_x + y*linesize];
2734 }
2735
2736 //right
2737 for(x=end_x; x<block_w; x++){
2738 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2739 }
2740 }
2741 }
2742
2743 static inline int hpel_motion(MpegEncContext *s,
2744 uint8_t *dest, uint8_t *src,
2745 int field_based, int field_select,
2746 int src_x, int src_y,
2747 int width, int height, int stride,
2748 int h_edge_pos, int v_edge_pos,
2749 int w, int h, op_pixels_func *pix_op,
2750 int motion_x, int motion_y)
2751 {
2752 int dxy;
2753 int emu=0;
2754
2755 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2756 src_x += motion_x >> 1;
2757 src_y += motion_y >> 1;
2758
2759 /* WARNING: do no forget half pels */
2760 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2761 if (src_x == width)
2762 dxy &= ~1;
2763 src_y = clip(src_y, -16, height);
2764 if (src_y == height)
2765 dxy &= ~2;
2766 src += src_y * stride + src_x;
2767
2768 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2769 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2770 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2771 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2772 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2773 src= s->edge_emu_buffer;
2774 emu=1;
2775 }
2776 }
2777 if(field_select)
2778 src += s->linesize;
2779 pix_op[dxy](dest, src, stride, h);
2780 return emu;
2781 }
2782
2783 static inline int hpel_motion_lowres(MpegEncContext *s,
2784 uint8_t *dest, uint8_t *src,
2785 int field_based, int field_select,
2786 int src_x, int src_y,
2787 int width, int height, int stride,
2788 int h_edge_pos, int v_edge_pos,
2789 int w, int h, h264_chroma_mc_func *pix_op,
2790 int motion_x, int motion_y)
2791 {
2792 const int lowres= s->avctx->lowres;
2793 const int s_mask= (2<<lowres)-1;
2794 int emu=0;
2795 int sx, sy;
2796
2797 if(s->quarter_sample){
2798 motion_x/=2;
2799 motion_y/=2;
2800 }
2801
2802 sx= motion_x & s_mask;
2803 sy= motion_y & s_mask;
2804 src_x += motion_x >> (lowres+1);