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