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