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