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