0190c91b5d12ac58d23bfd9ceacb210813608a04
[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 dsputil_init(&s->dsp, s->avctx);
623 DCT_common_init(s);
624
625 s->flags= s->avctx->flags;
626 s->flags2= s->avctx->flags2;
627
628 s->mb_width = (s->width + 15) / 16;
629 s->mb_height = (s->height + 15) / 16;
630 s->mb_stride = s->mb_width + 1;
631 s->b8_stride = s->mb_width*2 + 1;
632 s->b4_stride = s->mb_width*4 + 1;
633 mb_array_size= s->mb_height * s->mb_stride;
634 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
635
636 /* set chroma shifts */
637 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
638 &(s->chroma_y_shift) );
639
640 /* set default edge pos, will be overriden in decode_header if needed */
641 s->h_edge_pos= s->mb_width*16;
642 s->v_edge_pos= s->mb_height*16;
643
644 s->mb_num = s->mb_width * s->mb_height;
645
646 s->block_wrap[0]=
647 s->block_wrap[1]=
648 s->block_wrap[2]=
649 s->block_wrap[3]= s->b8_stride;
650 s->block_wrap[4]=
651 s->block_wrap[5]= s->mb_stride;
652
653 y_size = s->b8_stride * (2 * s->mb_height + 1);
654 c_size = s->mb_stride * (s->mb_height + 1);
655 yc_size = y_size + 2 * c_size;
656
657 /* convert fourcc to upper case */
658 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
659 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
660 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
661 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
662
663 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
664 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
665 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
666 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
667
668 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
669
670 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
671 for(y=0; y<s->mb_height; y++){
672 for(x=0; x<s->mb_width; x++){
673 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
674 }
675 }
676 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
677
678 if (s->encoding) {
679 /* Allocate MV tables */
680 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
681 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
682 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
683 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
684 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
685 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
687 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
688 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
689 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
690 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
691 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
692
693 if(s->msmpeg4_version){
694 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
695 }
696 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
697
698 /* Allocate MB type table */
699 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
700
701 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
702
703 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
704 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
705 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
706 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
707 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
708 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
709
710 if(s->avctx->noise_reduction){
711 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
712 }
713 }
714 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
715
716 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
717
718 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
719 /* interlaced direct mode decoding tables */
720 for(i=0; i<2; i++){
721 int j, k;
722 for(j=0; j<2; j++){
723 for(k=0; k<2; k++){
724 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
725 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
726 }
727 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
728 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
729 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
730 }
731 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
732 }
733 }
734 if (s->out_format == FMT_H263) {
735 /* ac values */
736 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
737 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
738 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
739 s->ac_val[2] = s->ac_val[1] + c_size;
740
741 /* cbp values */
742 CHECKED_ALLOCZ(s->coded_block_base, y_size);
743 s->coded_block= s->coded_block_base + s->b8_stride + 1;
744
745 /* divx501 bitstream reorder buffer */
746 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
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 av_freep(&s->avctx->stats_out);
853 av_freep(&s->ac_stats);
854 av_freep(&s->error_status_table);
855 av_freep(&s->mb_index2xy);
856 av_freep(&s->lambda_table);
857 av_freep(&s->q_intra_matrix);
858 av_freep(&s->q_inter_matrix);
859 av_freep(&s->q_intra_matrix16);
860 av_freep(&s->q_inter_matrix16);
861 av_freep(&s->input_picture);
862 av_freep(&s->reordered_input_picture);
863 av_freep(&s->dct_offset);
864
865 if(s->picture){
866 for(i=0; i<MAX_PICTURE_COUNT; i++){
867 free_picture(s, &s->picture[i]);
868 }
869 }
870 av_freep(&s->picture);
871 s->context_initialized = 0;
872 s->last_picture_ptr=
873 s->next_picture_ptr=
874 s->current_picture_ptr= NULL;
875 s->linesize= s->uvlinesize= 0;
876
877 for(i=0; i<3; i++)
878 av_freep(&s->visualization_buffer[i]);
879
880 avcodec_default_free_buffers(s->avctx);
881 }
882
883 #ifdef CONFIG_ENCODERS
884
885 /* init video encoder */
886 int MPV_encode_init(AVCodecContext *avctx)
887 {
888 MpegEncContext *s = avctx->priv_data;
889 int i, dummy;
890 int chroma_h_shift, chroma_v_shift;
891
892 MPV_encode_defaults(s);
893
894 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
895
896 s->bit_rate = avctx->bit_rate;
897 s->width = avctx->width;
898 s->height = avctx->height;
899 if(avctx->gop_size > 600){
900 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
901 avctx->gop_size=600;
902 }
903 s->gop_size = avctx->gop_size;
904 s->avctx = avctx;
905 s->flags= avctx->flags;
906 s->flags2= avctx->flags2;
907 s->max_b_frames= avctx->max_b_frames;
908 s->codec_id= avctx->codec->id;
909 s->luma_elim_threshold = avctx->luma_elim_threshold;
910 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
911 s->strict_std_compliance= avctx->strict_std_compliance;
912 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
913 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
914 s->mpeg_quant= avctx->mpeg_quant;
915 s->rtp_mode= !!avctx->rtp_payload_size;
916 s->intra_dc_precision= avctx->intra_dc_precision;
917 s->user_specified_pts = AV_NOPTS_VALUE;
918
919 if (s->gop_size <= 1) {
920 s->intra_only = 1;
921 s->gop_size = 12;
922 } else {
923 s->intra_only = 0;
924 }
925
926 s->me_method = avctx->me_method;
927
928 /* Fixed QSCALE */
929 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
930
931 s->adaptive_quant= ( s->avctx->lumi_masking
932 || s->avctx->dark_masking
933 || s->avctx->temporal_cplx_masking
934 || s->avctx->spatial_cplx_masking
935 || s->avctx->p_masking
936 || (s->flags&CODEC_FLAG_QP_RD))
937 && !s->fixed_qscale;
938
939 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
940 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
941 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
942
943 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
944 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
945 return -1;
946 }
947
948 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
949 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
950 }
951
952 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
953 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
954 return -1;
955 }
956
957 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
958 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
959 return -1;
960 }
961
962 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
963 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
964 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
965
966 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");
967 }
968
969 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
970 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
971 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
972 return -1;
973 }
974
975 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
976 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
977 return -1;
978 }
979
980 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
981 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
982 return -1;
983 }
984
985 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
986 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
987 return -1;
988 }
989
990 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
991 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
992 return -1;
993 }
994
995 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
996 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
997 return -1;
998 }
999
1000 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1001 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1002 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1003 return -1;
1004 }
1005
1006 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1007 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1008 return -1;
1009 }
1010
1011 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1012 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1013 return -1;
1014 }
1015
1016 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1017 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1018 return -1;
1019 }
1020
1021 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1022 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1023 return -1;
1024 }
1025
1026 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1027 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1028 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1029 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1030 return -1;
1031 }
1032
1033 if(s->avctx->thread_count > 1)
1034 s->rtp_mode= 1;
1035
1036 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1037 if(i > 1){
1038 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1039 avctx->frame_rate /= i;
1040 avctx->frame_rate_base /= i;
1041 // return -1;
1042 }
1043
1044 if(s->codec_id==CODEC_ID_MJPEG){
1045 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1046 s->inter_quant_bias= 0;
1047 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1048 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1049 s->inter_quant_bias= 0;
1050 }else{
1051 s->intra_quant_bias=0;
1052 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1053 }
1054
1055 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1056 s->intra_quant_bias= avctx->intra_quant_bias;
1057 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1058 s->inter_quant_bias= avctx->inter_quant_bias;
1059
1060 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1061
1062 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1063 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1064
1065 switch(avctx->codec->id) {
1066 case CODEC_ID_MPEG1VIDEO:
1067 s->out_format = FMT_MPEG1;
1068 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1069 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1070 break;
1071 case CODEC_ID_MPEG2VIDEO:
1072 s->out_format = FMT_MPEG1;
1073 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1074 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1075 s->rtp_mode= 1;
1076 break;
1077 case CODEC_ID_LJPEG:
1078 case CODEC_ID_MJPEG:
1079 s->out_format = FMT_MJPEG;
1080 s->intra_only = 1; /* force intra only for jpeg */
1081 s->mjpeg_write_tables = 1; /* write all tables */
1082 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1083 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1084 s->mjpeg_vsample[1] = 1;
1085 s->mjpeg_vsample[2] = 1;
1086 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1087 s->mjpeg_hsample[1] = 1;
1088 s->mjpeg_hsample[2] = 1;
1089 if (mjpeg_init(s) < 0)
1090 return -1;
1091 avctx->delay=0;
1092 s->low_delay=1;
1093 break;
1094 #ifdef CONFIG_RISKY
1095 case CODEC_ID_H261:
1096 s->out_format = FMT_H261;
1097 avctx->delay=0;
1098 s->low_delay=1;
1099 break;
1100 case CODEC_ID_H263:
1101 if (h263_get_picture_format(s->width, s->height) == 7) {
1102 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1103 return -1;
1104 }
1105 s->out_format = FMT_H263;
1106 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1107 avctx->delay=0;
1108 s->low_delay=1;
1109 break;
1110 case CODEC_ID_H263P:
1111 s->out_format = FMT_H263;
1112 s->h263_plus = 1;
1113 /* Fx */
1114 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1115 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1116 s->modified_quant= s->h263_aic;
1117 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1118 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1119 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1120 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1121 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1122
1123 /* /Fx */
1124 /* These are just to be sure */
1125 avctx->delay=0;
1126 s->low_delay=1;
1127 break;
1128 case CODEC_ID_FLV1:
1129 s->out_format = FMT_H263;
1130 s->h263_flv = 2; /* format = 1; 11-bit codes */
1131 s->unrestricted_mv = 1;
1132 s->rtp_mode=0; /* don't allow GOB */
1133 avctx->delay=0;
1134 s->low_delay=1;
1135 break;
1136 case CODEC_ID_RV10:
1137 s->out_format = FMT_H263;
1138 avctx->delay=0;
1139 s->low_delay=1;
1140 break;
1141 case CODEC_ID_RV20:
1142 s->out_format = FMT_H263;
1143 avctx->delay=0;
1144 s->low_delay=1;
1145 s->modified_quant=1;
1146 s->h263_aic=1;
1147 s->h263_plus=1;
1148 s->loop_filter=1;
1149 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1150 break;
1151 case CODEC_ID_MPEG4:
1152 s->out_format = FMT_H263;
1153 s->h263_pred = 1;
1154 s->unrestricted_mv = 1;
1155 s->low_delay= s->max_b_frames ? 0 : 1;
1156 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1157 break;
1158 case CODEC_ID_MSMPEG4V1:
1159 s->out_format = FMT_H263;
1160 s->h263_msmpeg4 = 1;
1161 s->h263_pred = 1;
1162 s->unrestricted_mv = 1;
1163 s->msmpeg4_version= 1;
1164 avctx->delay=0;
1165 s->low_delay=1;
1166 break;
1167 case CODEC_ID_MSMPEG4V2:
1168 s->out_format = FMT_H263;
1169 s->h263_msmpeg4 = 1;
1170 s->h263_pred = 1;
1171 s->unrestricted_mv = 1;
1172 s->msmpeg4_version= 2;
1173 avctx->delay=0;
1174 s->low_delay=1;
1175 break;
1176 case CODEC_ID_MSMPEG4V3:
1177 s->out_format = FMT_H263;
1178 s->h263_msmpeg4 = 1;
1179 s->h263_pred = 1;
1180 s->unrestricted_mv = 1;
1181 s->msmpeg4_version= 3;
1182 s->flipflop_rounding=1;
1183 avctx->delay=0;
1184 s->low_delay=1;
1185 break;
1186 case CODEC_ID_WMV1:
1187 s->out_format = FMT_H263;
1188 s->h263_msmpeg4 = 1;
1189 s->h263_pred = 1;
1190 s->unrestricted_mv = 1;
1191 s->msmpeg4_version= 4;
1192 s->flipflop_rounding=1;
1193 avctx->delay=0;
1194 s->low_delay=1;
1195 break;
1196 case CODEC_ID_WMV2:
1197 s->out_format = FMT_H263;
1198 s->h263_msmpeg4 = 1;
1199 s->h263_pred = 1;
1200 s->unrestricted_mv = 1;
1201 s->msmpeg4_version= 5;
1202 s->flipflop_rounding=1;
1203 avctx->delay=0;
1204 s->low_delay=1;
1205 break;
1206 #endif
1207 default:
1208 return -1;
1209 }
1210
1211 avctx->has_b_frames= !s->low_delay;
1212
1213 s->encoding = 1;
1214
1215 /* init */
1216 if (MPV_common_init(s) < 0)
1217 return -1;
1218
1219 if(s->modified_quant)
1220 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1221 s->progressive_frame=
1222 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1223 s->quant_precision=5;
1224
1225 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1226 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1227
1228 #ifdef CONFIG_ENCODERS
1229 #ifdef CONFIG_RISKY
1230 if (s->out_format == FMT_H261)
1231 ff_h261_encode_init(s);
1232 if (s->out_format == FMT_H263)
1233 h263_encode_init(s);
1234 if(s->msmpeg4_version)
1235 ff_msmpeg4_encode_init(s);
1236 #endif
1237 if (s->out_format == FMT_MPEG1)
1238 ff_mpeg1_encode_init(s);
1239 #endif
1240
1241 /* init q matrix */
1242 for(i=0;i<64;i++) {
1243 int j= s->dsp.idct_permutation[i];
1244 #ifdef CONFIG_RISKY
1245 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1246 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1247 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1248 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1249 s->intra_matrix[j] =
1250 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1251 }else
1252 #endif
1253 { /* mpeg1/2 */
1254 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1255 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1256 }
1257 if(s->avctx->intra_matrix)
1258 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1259 if(s->avctx->inter_matrix)
1260 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1261 }
1262
1263 /* precompute matrix */
1264 /* for mjpeg, we do include qscale in the matrix */
1265 if (s->out_format != FMT_MJPEG) {
1266 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1267 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1268 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1269 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1270 }
1271
1272 if(ff_rate_control_init(s) < 0)
1273 return -1;
1274
1275 return 0;
1276 }
1277
1278 int MPV_encode_end(AVCodecContext *avctx)
1279 {
1280 MpegEncContext *s = avctx->priv_data;
1281
1282 #ifdef STATS
1283 print_stats();
1284 #endif
1285
1286 ff_rate_control_uninit(s);
1287
1288 MPV_common_end(s);
1289 if (s->out_format == FMT_MJPEG)
1290 mjpeg_close(s);
1291
1292 av_freep(&avctx->extradata);
1293
1294 return 0;
1295 }
1296
1297 #endif //CONFIG_ENCODERS
1298
1299 void init_rl(RLTable *rl, int use_static)
1300 {
1301 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1302 uint8_t index_run[MAX_RUN+1];
1303 int last, run, level, start, end, i;
1304
1305 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1306 if(use_static && rl->max_level[0])
1307 return;
1308
1309 /* compute max_level[], max_run[] and index_run[] */
1310 for(last=0;last<2;last++) {
1311 if (last == 0) {
1312 start = 0;
1313 end = rl->last;
1314 } else {
1315 start = rl->last;
1316 end = rl->n;
1317 }
1318
1319 memset(max_level, 0, MAX_RUN + 1);
1320 memset(max_run, 0, MAX_LEVEL + 1);
1321 memset(index_run, rl->n, MAX_RUN + 1);
1322 for(i=start;i<end;i++) {
1323 run = rl->table_run[i];
1324 level = rl->table_level[i];
1325 if (index_run[run] == rl->n)
1326 index_run[run] = i;
1327 if (level > max_level[run])
1328 max_level[run] = level;
1329 if (run > max_run[level])
1330 max_run[level] = run;
1331 }
1332 if(use_static)
1333 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1334 else
1335 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1336 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1337 if(use_static)
1338 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1339 else
1340 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1341 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1342 if(use_static)
1343 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1344 else
1345 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1346 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1347 }
1348 }
1349
1350 /* draw the edges of width 'w' of an image of size width, height */
1351 //FIXME check that this is ok for mpeg4 interlaced
1352 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1353 {
1354 uint8_t *ptr, *last_line;
1355 int i;
1356
1357 last_line = buf + (height - 1) * wrap;
1358 for(i=0;i<w;i++) {
1359 /* top and bottom */
1360 memcpy(buf - (i + 1) * wrap, buf, width);
1361 memcpy(last_line + (i + 1) * wrap, last_line, width);
1362 }
1363 /* left and right */
1364 ptr = buf;
1365 for(i=0;i<height;i++) {
1366 memset(ptr - w, ptr[0], w);
1367 memset(ptr + width, ptr[width-1], w);
1368 ptr += wrap;
1369 }
1370 /* corners */
1371 for(i=0;i<w;i++) {
1372 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1373 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1374 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1375 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1376 }
1377 }
1378
1379 int ff_find_unused_picture(MpegEncContext *s, int shared){
1380 int i;
1381
1382 if(shared){
1383 for(i=0; i<MAX_PICTURE_COUNT; i++){
1384 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1385 }
1386 }else{
1387 for(i=0; i<MAX_PICTURE_COUNT; i++){
1388 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1389 }
1390 for(i=0; i<MAX_PICTURE_COUNT; i++){
1391 if(s->picture[i].data[0]==NULL) return i;
1392 }
1393 }
1394
1395 assert(0);
1396 return -1;
1397 }
1398
1399 static void update_noise_reduction(MpegEncContext *s){
1400 int intra, i;
1401
1402 for(intra=0; intra<2; intra++){
1403 if(s->dct_count[intra] > (1<<16)){
1404 for(i=0; i<64; i++){
1405 s->dct_error_sum[intra][i] >>=1;
1406 }
1407 s->dct_count[intra] >>= 1;
1408 }
1409
1410 for(i=0; i<64; i++){
1411 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);
1412 }
1413 }
1414 }
1415
1416 /**
1417 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1418 */
1419 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1420 {
1421 int i;
1422 AVFrame *pic;
1423 s->mb_skiped = 0;
1424
1425 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1426
1427 /* mark&release old frames */
1428 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1429 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1430
1431 /* release forgotten pictures */
1432 /* if(mpeg124/h263) */
1433 if(!s->encoding){
1434 for(i=0; i<MAX_PICTURE_COUNT; i++){
1435 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1436 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1437 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1438 }
1439 }
1440 }
1441 }
1442 alloc:
1443 if(!s->encoding){
1444 /* release non refernce frames */
1445 for(i=0; i<MAX_PICTURE_COUNT; i++){
1446 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1447 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1448 }
1449 }
1450
1451 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1452 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1453 else{
1454 i= ff_find_unused_picture(s, 0);
1455 pic= (AVFrame*)&s->picture[i];
1456 }
1457
1458 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1459
1460 pic->coded_picture_number= s->coded_picture_number++;
1461
1462 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1463 return -1;
1464
1465 s->current_picture_ptr= (Picture*)pic;
1466 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1467 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1468 }
1469
1470 s->current_picture_ptr->pict_type= s->pict_type;
1471 // if(s->flags && CODEC_FLAG_QSCALE)
1472 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1473 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1474
1475 copy_picture(&s->current_picture, s->current_picture_ptr);
1476
1477 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1478 if (s->pict_type != B_TYPE) {
1479 s->last_picture_ptr= s->next_picture_ptr;
1480 if(!s->dropable)
1481 s->next_picture_ptr= s->current_picture_ptr;
1482 }
1483 /* 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,
1484 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1485 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1486 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1487 s->pict_type, s->dropable);*/
1488
1489 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1490 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1491
1492 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1493 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1494 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1495 goto alloc;
1496 }
1497
1498 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1499
1500 if(s->picture_structure!=PICT_FRAME){
1501 int i;
1502 for(i=0; i<4; i++){
1503 if(s->picture_structure == PICT_BOTTOM_FIELD){
1504 s->current_picture.data[i] += s->current_picture.linesize[i];
1505 }
1506 s->current_picture.linesize[i] *= 2;
1507 s->last_picture.linesize[i] *=2;
1508 s->next_picture.linesize[i] *=2;
1509 }
1510 }
1511 }
1512
1513 s->hurry_up= s->avctx->hurry_up;
1514 s->error_resilience= avctx->error_resilience;
1515
1516 /* set dequantizer, we cant do it during init as it might change for mpeg4
1517 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1518 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1519 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1520 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1521 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1522 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1523 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1524 }else{
1525 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1526 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1527 }
1528
1529 if(s->dct_error_sum){
1530 assert(s->avctx->noise_reduction && s->encoding);
1531
1532 update_noise_reduction(s);
1533 }
1534
1535 #ifdef HAVE_XVMC
1536 if(s->avctx->xvmc_acceleration)
1537 return XVMC_field_start(s, avctx);
1538 #endif
1539 return 0;
1540 }
1541
1542 /* generic function for encode/decode called after a frame has been coded/decoded */
1543 void MPV_frame_end(MpegEncContext *s)
1544 {
1545 int i;
1546 /* draw edge for correct motion prediction if outside */
1547 #ifdef HAVE_XVMC
1548 //just to make sure that all data is rendered.
1549 if(s->avctx->xvmc_acceleration){
1550 XVMC_field_end(s);
1551 }else
1552 #endif
1553 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1554 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1555 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1556 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1557 }
1558 emms_c();
1559
1560 s->last_pict_type = s->pict_type;
1561 if(s->pict_type!=B_TYPE){
1562 s->last_non_b_pict_type= s->pict_type;
1563 }
1564 #if 0
1565 /* copy back current_picture variables */
1566 for(i=0; i<MAX_PICTURE_COUNT; i++){
1567 if(s->picture[i].data[0] == s->current_picture.data[0]){
1568 s->picture[i]= s->current_picture;
1569 break;
1570 }
1571 }
1572 assert(i<MAX_PICTURE_COUNT);
1573 #endif
1574
1575 if(s->encoding){
1576 /* release non refernce frames */
1577 for(i=0; i<MAX_PICTURE_COUNT; i++){
1578 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1579 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1580 }
1581 }
1582 }
1583 // clear copies, to avoid confusion
1584 #if 0
1585 memset(&s->last_picture, 0, sizeof(Picture));
1586 memset(&s->next_picture, 0, sizeof(Picture));
1587 memset(&s->current_picture, 0, sizeof(Picture));
1588 #endif
1589 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1590 }
1591
1592 /**
1593 * draws an line from (ex, ey) -> (sx, sy).
1594 * @param w width of the image
1595 * @param h height of the image
1596 * @param stride stride/linesize of the image
1597 * @param color color of the arrow
1598 */
1599 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1600 int t, x, y, fr, f;
1601
1602 sx= clip(sx, 0, w-1);
1603 sy= clip(sy, 0, h-1);
1604 ex= clip(ex, 0, w-1);
1605 ey= clip(ey, 0, h-1);
1606
1607 buf[sy*stride + sx]+= color;
1608
1609 if(ABS(ex - sx) > ABS(ey - sy)){
1610 if(sx > ex){
1611 t=sx; sx=ex; ex=t;
1612 t=sy; sy=ey; ey=t;
1613 }
1614 buf+= sx + sy*stride;
1615 ex-= sx;
1616 f= ((ey-sy)<<16)/ex;
1617 for(x= 0; x <= ex; x++){
1618 y = (x*f)>>16;
1619 fr= (x*f)&0xFFFF;
1620 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1621 buf[(y+1)*stride + x]+= (color* fr )>>16;
1622 }
1623 }else{
1624 if(sy > ey){
1625 t=sx; sx=ex; ex=t;
1626 t=sy; sy=ey; ey=t;
1627 }
1628 buf+= sx + sy*stride;
1629 ey-= sy;
1630 if(ey) f= ((ex-sx)<<16)/ey;
1631 else f= 0;
1632 for(y= 0; y <= ey; y++){
1633 x = (y*f)>>16;
1634 fr= (y*f)&0xFFFF;
1635 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1636 buf[y*stride + x+1]+= (color* fr )>>16;;
1637 }
1638 }
1639 }
1640
1641 /**
1642 * draws an arrow from (ex, ey) -> (sx, sy).
1643 * @param w width of the image
1644 * @param h height of the image
1645 * @param stride stride/linesize of the image
1646 * @param color color of the arrow
1647 */
1648 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1649 int dx,dy;
1650
1651 sx= clip(sx, -100, w+100);
1652 sy= clip(sy, -100, h+100);
1653 ex= clip(ex, -100, w+100);
1654 ey= clip(ey, -100, h+100);
1655
1656 dx= ex - sx;
1657 dy= ey - sy;
1658
1659 if(dx*dx + dy*dy > 3*3){
1660 int rx= dx + dy;
1661 int ry= -dx + dy;
1662 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1663
1664 //FIXME subpixel accuracy
1665 rx= ROUNDED_DIV(rx*3<<4, length);
1666 ry= ROUNDED_DIV(ry*3<<4, length);
1667
1668 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1669 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1670 }
1671 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1672 }
1673
1674 /**
1675 * prints debuging info for the given picture.
1676 */
1677 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1678
1679 if(!pict || !pict->mb_type) return;
1680
1681 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1682 int x,y;
1683
1684 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1685 switch (pict->pict_type) {
1686 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1687 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1688 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1689 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1690 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1691 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1692 }
1693 for(y=0; y<s->mb_height; y++){
1694 for(x=0; x<s->mb_width; x++){
1695 if(s->avctx->debug&FF_DEBUG_SKIP){
1696 int count= s->mbskip_table[x + y*s->mb_stride];
1697 if(count>9) count=9;
1698 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1699 }
1700 if(s->avctx->debug&FF_DEBUG_QP){
1701 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1702 }
1703 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1704 int mb_type= pict->mb_type[x + y*s->mb_stride];
1705 //Type & MV direction
1706 if(IS_PCM(mb_type))
1707 av_log(s->avctx, AV_LOG_DEBUG, "P");
1708 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1709 av_log(s->avctx, AV_LOG_DEBUG, "A");
1710 else if(IS_INTRA4x4(mb_type))
1711 av_log(s->avctx, AV_LOG_DEBUG, "i");
1712 else if(IS_INTRA16x16(mb_type))
1713 av_log(s->avctx, AV_LOG_DEBUG, "I");
1714 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1715 av_log(s->avctx, AV_LOG_DEBUG, "d");
1716 else if(IS_DIRECT(mb_type))
1717 av_log(s->avctx, AV_LOG_DEBUG, "D");
1718 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1719 av_log(s->avctx, AV_LOG_DEBUG, "g");
1720 else if(IS_GMC(mb_type))
1721 av_log(s->avctx, AV_LOG_DEBUG, "G");
1722 else if(IS_SKIP(mb_type))
1723 av_log(s->avctx, AV_LOG_DEBUG, "S");
1724 else if(!USES_LIST(mb_type, 1))
1725 av_log(s->avctx, AV_LOG_DEBUG, ">");
1726 else if(!USES_LIST(mb_type, 0))
1727 av_log(s->avctx, AV_LOG_DEBUG, "<");
1728 else{
1729 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1730 av_log(s->avctx, AV_LOG_DEBUG, "X");
1731 }
1732
1733 //segmentation
1734 if(IS_8X8(mb_type))
1735 av_log(s->avctx, AV_LOG_DEBUG, "+");
1736 else if(IS_16X8(mb_type))
1737 av_log(s->avctx, AV_LOG_DEBUG, "-");
1738 else if(IS_8X16(mb_type))
1739 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1740 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1741 av_log(s->avctx, AV_LOG_DEBUG, " ");
1742 else
1743 av_log(s->avctx, AV_LOG_DEBUG, "?");
1744
1745
1746 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1747 av_log(s->avctx, AV_LOG_DEBUG, "=");
1748 else
1749 av_log(s->avctx, AV_LOG_DEBUG, " ");
1750 }
1751 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1752 }
1753 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1754 }
1755 }
1756
1757 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1758 const int shift= 1 + s->quarter_sample;
1759 int mb_y;
1760 uint8_t *ptr;
1761 int i;
1762 int h_chroma_shift, v_chroma_shift;
1763 const int width = s->avctx->width;
1764 const int height= s->avctx->height;
1765 s->low_delay=0; //needed to see the vectors without trashing the buffers
1766
1767 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1768 for(i=0; i<3; i++){
1769 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1770 pict->data[i]= s->visualization_buffer[i];
1771 }
1772 pict->type= FF_BUFFER_TYPE_COPY;
1773 ptr= pict->data[0];
1774
1775 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1776 int mb_x;
1777 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1778 const int mb_index= mb_x + mb_y*s->mb_stride;
1779 if((s->avctx->debug_mv) && pict->motion_val){
1780 int type;
1781 for(type=0; type<3; type++){
1782 int direction = 0;
1783 switch (type) {
1784 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1785 continue;
1786 direction = 0;
1787 break;
1788 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1789 continue;
1790 direction = 0;
1791 break;
1792 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1793 continue;
1794 direction = 1;
1795 break;
1796 }
1797 if(!USES_LIST(pict->mb_type[mb_index], direction))
1798 continue;
1799
1800 //FIXME for h264
1801 if(IS_8X8(pict->mb_type[mb_index])){
1802 int i;
1803 for(i=0; i<4; i++){
1804 int sx= mb_x*16 + 4 + 8*(i&1);
1805 int sy= mb_y*16 + 4 + 8*(i>>1);
1806 int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1807 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1808 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1809 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1810 }
1811 }else if(IS_16X8(pict->mb_type[mb_index])){
1812 int i;
1813 for(i=0; i<2; i++){
1814 int sx=mb_x*16 + 8;
1815 int sy=mb_y*16 + 4 + 8*i;
1816 int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1817 int mx=(pict->motion_val[direction][xy][0]>>shift);
1818 int my=(pict->motion_val[direction][xy][1]>>shift);
1819
1820 if(IS_INTERLACED(pict->mb_type[mb_index]))
1821 my*=2;
1822
1823 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1824 }
1825 }else{
1826 int sx= mb_x*16 + 8;
1827 int sy= mb_y*16 + 8;
1828 int xy= mb_x*2 + mb_y*2*s->b8_stride;
1829 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1830 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1831 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1832 }
1833 }
1834 }
1835 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1836 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1837 int y;
1838 for(y=0; y<8; y++){
1839 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1840 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1841 }
1842 }
1843 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1844 int mb_type= pict->mb_type[mb_index];
1845 uint64_t u,v;
1846 int y;
1847 #define COLOR(theta, r)\
1848 u= (int)(128 + r*cos(theta*3.141592/180));\
1849 v= (int)(128 + r*sin(theta*3.141592/180));
1850
1851
1852 u=v=128;
1853 if(IS_PCM(mb_type)){
1854 COLOR(120,48)
1855 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1856 COLOR(30,48)
1857 }else if(IS_INTRA4x4(mb_type)){
1858 COLOR(90,48)
1859 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1860 // COLOR(120,48)
1861 }else if(IS_DIRECT(mb_type)){
1862 COLOR(150,48)
1863 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1864 COLOR(170,48)
1865 }else if(IS_GMC(mb_type)){
1866 COLOR(190,48)
1867 }else if(IS_SKIP(mb_type)){
1868 // COLOR(180,48)
1869 }else if(!USES_LIST(mb_type, 1)){
1870 COLOR(240,48)
1871 }else if(!USES_LIST(mb_type, 0)){
1872 COLOR(0,48)
1873 }else{
1874 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1875 COLOR(300,48)
1876 }
1877
1878 u*= 0x0101010101010101ULL;
1879 v*= 0x0101010101010101ULL;
1880 for(y=0; y<8; y++){
1881 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1882 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1883 }
1884
1885 //segmentation
1886 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1887 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1888 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1889 }
1890 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1891 for(y=0; y<16; y++)
1892 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1893 }
1894
1895 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1896 // hmm
1897 }
1898 }
1899 s->mbskip_table[mb_index]=0;
1900 }
1901 }
1902 }
1903 }
1904
1905 #ifdef CONFIG_ENCODERS
1906
1907 static int get_sae(uint8_t *src, int ref, int stride){
1908 int x,y;
1909 int acc=0;
1910
1911 for(y=0; y<16; y++){
1912 for(x=0; x<16; x++){
1913 acc+= ABS(src[x+y*stride] - ref);
1914 }
1915 }
1916
1917 return acc;
1918 }
1919
1920 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1921 int x, y, w, h;
1922 int acc=0;
1923
1924 w= s->width &~15;
1925 h= s->height&~15;
1926
1927 for(y=0; y<h; y+=16){
1928 for(x=0; x<w; x+=16){
1929 int offset= x + y*stride;
1930 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1931 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1932 int sae = get_sae(src + offset, mean, stride);
1933
1934 acc+= sae + 500 < sad;
1935 }
1936 }
1937 return acc;
1938 }
1939
1940
1941 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1942 AVFrame *pic=NULL;
1943 int i;
1944 const int encoding_delay= s->max_b_frames;
1945 int direct=1;
1946
1947 if(pic_arg){
1948 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1949 if(pic_arg->linesize[0] != s->linesize) direct=0;
1950 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1951 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1952
1953 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1954
1955 if(direct){
1956 i= ff_find_unused_picture(s, 1);
1957
1958 pic= (AVFrame*)&s->picture[i];
1959 pic->reference= 3;
1960
1961 for(i=0; i<4; i++){
1962 pic->data[i]= pic_arg->data[i];
1963 pic->linesize[i]= pic_arg->linesize[i];
1964 }
1965 alloc_picture(s, (Picture*)pic, 1);
1966 }else{
1967 int offset= 16;
1968 i= ff_find_unused_picture(s, 0);
1969
1970 pic= (AVFrame*)&s->picture[i];
1971 pic->reference= 3;
1972
1973 alloc_picture(s, (Picture*)pic, 0);
1974
1975 if( pic->data[0] + offset == pic_arg->data[0]
1976 && pic->data[1] + offset == pic_arg->data[1]
1977 && pic->data[2] + offset == pic_arg->data[2]){
1978 // empty
1979 }else{
1980 int h_chroma_shift, v_chroma_shift;
1981 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1982
1983 for(i=0; i<3; i++){
1984 int src_stride= pic_arg->linesize[i];
1985 int dst_stride= i ? s->uvlinesize : s->linesize;
1986 int h_shift= i ? h_chroma_shift : 0;
1987 int v_shift= i ? v_chroma_shift : 0;
1988 int w= s->width >>h_shift;
1989 int h= s->height>>v_shift;
1990 uint8_t *src= pic_arg->data[i];
1991 uint8_t *dst= pic->data[i] + offset;
1992
1993 if(src_stride==dst_stride)
1994 memcpy(dst, src, src_stride*h);
1995 else{
1996 while(h--){
1997 memcpy(dst, src, w);
1998 dst += dst_stride;
1999 src += src_stride;
2000 }
2001 }
2002 }
2003 }
2004 }
2005 copy_picture_attributes(s, pic, pic_arg);
2006
2007 pic->display_picture_number= s->input_picture_number++;
2008
2009 if(pic->pts != AV_NOPTS_VALUE){
2010 if(s->user_specified_pts != AV_NOPTS_VALUE){
2011 int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2012 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2013
2014 if(time <= last){
2015 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
2016 return -1;
2017 }
2018 }
2019 s->user_specified_pts= pic->pts;
2020 }else{
2021 if(s->user_specified_pts != AV_NOPTS_VALUE){
2022 s->user_specified_pts=
2023 pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2024 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
2025 }else{
2026 pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2027 }
2028 }
2029 }
2030
2031 /* shift buffer entries */
2032 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2033 s->input_picture[i-1]= s->input_picture[i];
2034
2035 s->input_picture[encoding_delay]= (Picture*)pic;
2036
2037 return 0;
2038 }
2039
2040 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2041 int x, y, plane;
2042 int score=0;
2043 int64_t score64=0;
2044 int64_t threshold;
2045
2046 for(plane=0; plane<3; plane++){
2047 const int stride= p->linesize[plane];
2048 const int bw= plane ? 1 : 2;
2049 for(y=0; y<s->mb_height*bw; y++){
2050 for(x=0; x<s->mb_width*bw; x++){
2051 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);
2052
2053 switch(s->avctx->frame_skip_exp){
2054 case 0: score= FFMAX(score, v); break;
2055 case 1: score+= ABS(v);break;
2056 case 2: score+= v*v;break;
2057 case 3: score64+= ABS(v*v*(int64_t)v);break;
2058 case 4: score64+= v*v*(int64_t)(v*v);break;
2059 }
2060 }
2061 }
2062 }
2063
2064 if(score) score64= score;
2065
2066 if(score64 < s->avctx->frame_skip_threshold)
2067 return 1;
2068 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2069 return 1;
2070 return 0;
2071 }
2072
2073 static void select_input_picture(MpegEncContext *s){
2074 int i;
2075
2076 for(i=1; i<MAX_PICTURE_COUNT; i++)
2077 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2078 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2079
2080 /* set next picture types & ordering */
2081 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2082 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2083 s->reordered_input_picture[0]= s->input_picture[0];
2084 s->reordered_input_picture[0]->pict_type= I_TYPE;
2085 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2086 }else{
2087 int b_frames;
2088
2089 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2090 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2091 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2092
2093 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2094 for(i=0; i<4; i++)
2095 s->input_picture[0]->data[i]= NULL;
2096 s->input_picture[0]->type= 0;
2097 }else{
2098 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2099 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2100
2101 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2102 }
2103
2104 goto no_output_pic;
2105 }
2106 }
2107
2108 if(s->flags&CODEC_FLAG_PASS2){
2109 for(i=0; i<s->max_b_frames+1; i++){
2110 int pict_num= s->input_picture[0]->display_picture_number + i;
2111
2112 if(pict_num >= s->rc_context.num_entries)
2113 break;
2114 if(!s->input_picture[i]){
2115 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2116 break;
2117 }
2118
2119 s->input_picture[i]->pict_type=
2120 s->rc_context.entry[pict_num].new_pict_type;
2121 }
2122 }
2123
2124 if(s->avctx->b_frame_strategy==0){
2125 b_frames= s->max_b_frames;
2126 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2127 }else if(s->avctx->b_frame_strategy==1){
2128 for(i=1; i<s->max_b_frames+1; i++){
2129 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2130 s->input_picture[i]->b_frame_score=
2131 get_intra_count(s, s->input_picture[i ]->data[0],
2132 s->input_picture[i-1]->data[0], s->linesize) + 1;
2133 }
2134 }
2135 for(i=0; i<s->max_b_frames; i++){
2136 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2137 }
2138
2139 b_frames= FFMAX(0, i-1);
2140
2141 /* reset scores */
2142 for(i=0; i<b_frames+1; i++){
2143 s->input_picture[i]->b_frame_score=0;
2144 }
2145 }else{
2146 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2147 b_frames=0;
2148 }
2149
2150 emms_c();
2151 //static int b_count=0;
2152 //b_count+= b_frames;
2153 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2154
2155 for(i= b_frames - 1; i>=0; i--){
2156 int type= s->input_picture[i]->pict_type;
2157 if(type && type != B_TYPE)
2158 b_frames= i;
2159 }
2160 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2161 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2162 }
2163
2164 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2165 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2166 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2167 }else{
2168 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2169 b_frames=0;
2170 s->input_picture[b_frames]->pict_type= I_TYPE;
2171 }
2172 }
2173
2174 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2175 && b_frames
2176 && s->input_picture[b_frames]->pict_type== I_TYPE)
2177 b_frames--;
2178
2179 s->reordered_input_picture[0]= s->input_picture[b_frames];
2180 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2181 s->reordered_input_picture[0]->pict_type= P_TYPE;
2182 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2183 for(i=0; i<b_frames; i++){
2184 s->reordered_input_picture[i+1]= s->input_picture[i];
2185 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2186 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2187 }
2188 }
2189 }
2190 no_output_pic:
2191 if(s->reordered_input_picture[0]){
2192 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2193
2194 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2195
2196 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2197 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2198
2199 int i= ff_find_unused_picture(s, 0);
2200 Picture *pic= &s->picture[i];
2201
2202 /* mark us unused / free shared pic */
2203 for(i=0; i<4; i++)
2204 s->reordered_input_picture[0]->data[i]= NULL;
2205 s->reordered_input_picture[0]->type= 0;
2206
2207 pic->reference = s->reordered_input_picture[0]->reference;
2208
2209 alloc_picture(s, pic, 0);
2210
2211 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2212
2213 s->current_picture_ptr= pic;
2214 }else{
2215 // input is not a shared pix -> reuse buffer for current_pix
2216
2217 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2218 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2219
2220 s->current_picture_ptr= s->reordered_input_picture[0];
2221 for(i=0; i<4; i++){
2222 s->new_picture.data[i]+=16;
2223 }
2224 }
2225 copy_picture(&s->current_picture, s->current_picture_ptr);
2226
2227 s->picture_number= s->new_picture.display_picture_number;
2228 //printf("dpn:%d\n", s->picture_number);
2229 }else{
2230 memset(&s->new_picture, 0, sizeof(Picture));
2231 }
2232 }
2233
2234 int MPV_encode_picture(AVCodecContext *avctx,
2235 unsigned char *buf, int buf_size, void *data)
2236 {
2237 MpegEncContext *s = avctx->priv_data;
2238 AVFrame *pic_arg = data;
2239 int i, stuffing_count;
2240
2241 if(avctx->pix_fmt != PIX_FMT_YUV420P){
2242 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2243 return -1;
2244 }
2245
2246 for(i=0; i<avctx->thread_count; i++){
2247 int start_y= s->thread_context[i]->start_mb_y;
2248 int end_y= s->thread_context[i]-> end_mb_y;
2249 int h= s->mb_height;
2250 uint8_t *start= buf + buf_size*start_y/h;
2251 uint8_t *end = buf + buf_size* end_y/h;
2252
2253 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2254 }
2255
2256 s->picture_in_gop_number++;
2257
2258 if(load_input_picture(s, pic_arg) < 0)
2259 return -1;
2260
2261 select_input_picture(s);
2262
2263 /* output? */
2264 if(s->new_picture.data[0]){
2265 s->pict_type= s->new_picture.pict_type;
2266 //emms_c();
2267 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2268 MPV_frame_start(s, avctx);
2269
2270 encode_picture(s, s->picture_number);
2271
2272 avctx->real_pict_num = s->picture_number;
2273 avctx->header_bits = s->header_bits;
2274 avctx->mv_bits = s->mv_bits;
2275 avctx->misc_bits = s->misc_bits;
2276 avctx->i_tex_bits = s->i_tex_bits;
2277 avctx->p_tex_bits = s->p_tex_bits;
2278 avctx->i_count = s->i_count;
2279 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2280 avctx->skip_count = s->skip_count;
2281
2282 MPV_frame_end(s);
2283
2284 if (s->out_format == FMT_MJPEG)
2285 mjpeg_picture_trailer(s);
2286
2287 if(s->flags&CODEC_FLAG_PASS1)
2288 ff_write_pass1_stats(s);
2289
2290 for(i=0; i<4; i++){
2291 avctx->error[i] += s->current_picture_ptr->error[i];
2292 }
2293
2294 flush_put_bits(&s->pb);
2295 s->frame_bits = put_bits_count(&s->pb);
2296
2297 stuffing_count= ff_vbv_update(s, s->frame_bits);
2298 if(stuffing_count){
2299 switch(s->codec_id){
2300 case CODEC_ID_MPEG1VIDEO:
2301 case CODEC_ID_MPEG2VIDEO:
2302 while(stuffing_count--){
2303 put_bits(&s->pb, 8, 0);
2304 }
2305 break;
2306 case CODEC_ID_MPEG4:
2307 put_bits(&s->pb, 16, 0);
2308 put_bits(&s->pb, 16, 0x1C3);
2309 stuffing_count -= 4;
2310 while(stuffing_count--){
2311 put_bits(&s->pb, 8, 0xFF);
2312 }
2313 break;
2314 default:
2315 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2316 }
2317 flush_put_bits(&s->pb);
2318 s->frame_bits = put_bits_count(&s->pb);
2319 }
2320
2321 /* update mpeg1/2 vbv_delay for CBR */
2322 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2323 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2324 int vbv_delay;
2325
2326 assert(s->repeat_first_field==0);
2327
2328 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2329 assert(vbv_delay < 0xFFFF);
2330
2331 s->vbv_delay_ptr[0] &= 0xF8;
2332 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2333 s->vbv_delay_ptr[1] = vbv_delay>>5;
2334 s->vbv_delay_ptr[2] &= 0x07;
2335 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2336 }
2337 s->total_bits += s->frame_bits;
2338 avctx->frame_bits = s->frame_bits;
2339 }else{
2340 assert((pbBufPtr(&s->pb) == s->pb.buf));
2341 s->frame_bits=0;
2342 }
2343 assert((s->frame_bits&7)==0);
2344
2345 return s->frame_bits/8;
2346 }
2347
2348 #endif //CONFIG_ENCODERS
2349
2350 static inline void gmc1_motion(MpegEncContext *s,
2351 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2352 uint8_t **ref_picture)
2353 {
2354 uint8_t *ptr;
2355 int offset, src_x, src_y, linesize, uvlinesize;
2356 int motion_x, motion_y;
2357 int emu=0;
2358
2359 motion_x= s->sprite_offset[0][0];
2360 motion_y= s->sprite_offset[0][1];
2361 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2362 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2363 motion_x<<=(3-s->sprite_warping_accuracy);
2364 motion_y<<=(3-s->sprite_warping_accuracy);
2365 src_x = clip(src_x, -16, s->width);
2366 if (src_x == s->width)
2367 motion_x =0;
2368 src_y = clip(src_y, -16, s->height);
2369 if (src_y == s->height)
2370 motion_y =0;
2371
2372 linesize = s->linesize;
2373 uvlinesize = s->uvlinesize;
2374
2375 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2376
2377 if(s->flags&CODEC_FLAG_EMU_EDGE){
2378 if( (unsigned)src_x >= s->h_edge_pos - 17
2379 || (unsigned)src_y >= s->v_edge_pos - 17){
2380 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2381 ptr= s->edge_emu_buffer;
2382 }
2383 }
2384
2385 if((motion_x|motion_y)&7){
2386 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2387 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2388 }else{
2389 int dxy;
2390
2391 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2392 if (s->no_rounding){
2393 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2394 }else{
2395 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2396 }
2397 }
2398
2399 if(s->flags&CODEC_FLAG_GRAY) return;
2400
2401 motion_x= s->sprite_offset[1][0];
2402 motion_y= s->sprite_offset[1][1];
2403 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2404 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2405 motion_x<<=(3-s->sprite_warping_accuracy);
2406 motion_y<<=(3-s->sprite_warping_accuracy);
2407 src_x = clip(src_x, -8, s->width>>1);
2408 if (src_x == s->width>>1)
2409 motion_x =0;
2410 src_y = clip(src_y, -8, s->height>>1);
2411 if (src_y == s->height>>1)
2412 motion_y =0;
2413
2414 offset = (src_y * uvlinesize) + src_x;
2415 ptr = ref_picture[1] + offset;
2416 if(s->flags&CODEC_FLAG_EMU_EDGE){
2417 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2418 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2419 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);
2420 ptr= s->edge_emu_buffer;
2421 emu=1;
2422 }
2423 }
2424 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2425
2426 ptr = ref_picture[2] + offset;
2427 if(emu){
2428 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);
2429 ptr= s->edge_emu_buffer;
2430 }
2431 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2432
2433 return;
2434 }
2435
2436 static inline void gmc_motion(MpegEncContext *s,
2437 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2438 uint8_t **ref_picture)
2439 {
2440 uint8_t *ptr;
2441 int linesize, uvlinesize;
2442 const int a= s->sprite_warping_accuracy;
2443 int ox, oy;
2444
2445 linesize = s->linesize;
2446 uvlinesize = s->uvlinesize;
2447
2448 ptr = ref_picture[0];
2449
2450 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2451 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2452
2453 s->dsp.gmc(dest_y, ptr, linesize, 16,
2454 ox,
2455 oy,
2456 s->sprite_delta[0][0], s->sprite_delta[0][1],
2457 s->sprite_delta[1][0], s->sprite_delta[1][1],
2458 a+1, (1<<(2*a+1)) - s->no_rounding,
2459 s->h_edge_pos, s->v_edge_pos);
2460 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2461 ox + s->sprite_delta[0][0]*8,
2462 oy + s->sprite_delta[1][0]*8,
2463 s->sprite_delta[0][0], s->sprite_delta[0][1],
2464 s->sprite_delta[1][0], s->sprite_delta[1][1],
2465 a+1, (1<<(2*a+1)) - s->no_rounding,
2466 s->h_edge_pos, s->v_edge_pos);
2467
2468 if(s->flags&CODEC_FLAG_GRAY) return;
2469
2470 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2471 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2472
2473 ptr = ref_picture[1];
2474 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2475 ox,
2476 oy,
2477 s->sprite_delta[0][0], s->sprite_delta[0][1],
2478 s->sprite_delta[1][0], s->sprite_delta[1][1],
2479 a+1, (1<<(2*a+1)) - s->no_rounding,
2480 s->h_edge_pos>>1, s->v_edge_pos>>1);
2481
2482 ptr = ref_picture[2];
2483 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2484 ox,
2485 oy,
2486 s->sprite_delta[0][0], s->sprite_delta[0][1],
2487 s->sprite_delta[1][0], s->sprite_delta[1][1],
2488 a+1, (1<<(2*a+1)) - s->no_rounding,
2489 s->h_edge_pos>>1, s->v_edge_pos>>1);
2490 }
2491
2492 /**
2493 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2494 * @param buf destination buffer
2495 * @param src source buffer
2496 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2497 * @param block_w width of block
2498 * @param block_h height of block
2499 * @param src_x x coordinate of the top left sample of the block in the source buffer
2500 * @param src_y y coordinate of the top left sample of the block in the source buffer
2501 * @param w width of the source buffer
2502 * @param h height of the source buffer
2503 */
2504 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2505 int src_x, int src_y, int w, int h){
2506 int x, y;
2507 int start_y, start_x, end_y, end_x;
2508
2509 if(src_y>= h){
2510 src+= (h-1-src_y)*linesize;
2511 src_y=h-1;
2512 }else if(src_y<=-block_h){
2513 src+= (1-block_h-src_y)*linesize;
2514 src_y=1-block_h;
2515 }
2516 if(src_x>= w){
2517 src+= (w-1-src_x);
2518 src_x=w-1;
2519 }else if(src_x<=-block_w){
2520 src+= (1-block_w-src_x);
2521 src_x=1-block_w;
2522 }
2523
2524 start_y= FFMAX(0, -src_y);
2525 start_x= FFMAX(0, -src_x);
2526 end_y= FFMIN(block_h, h-src_y);
2527 end_x= FFMIN(block_w, w-src_x);
2528
2529 // copy existing part
2530 for(y=start_y; y<end_y; y++){
2531 for(x=start_x; x<end_x; x++){
2532 buf[x + y*linesize]= src[x + y*linesize];
2533 }
2534 }
2535
2536 //top
2537 for(y=0; y<start_y; y++){
2538 for(x=start_x; x<end_x; x++){
2539 buf[x + y*linesize]= buf[x + start_y*linesize];
2540 }
2541 }
2542
2543 //bottom
2544 for(y=end_y; y<block_h; y++){
2545 for(x=start_x; x<end_x; x++){
2546 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2547 }
2548 }
2549
2550 for(y=0; y<block_h; y++){
2551 //left
2552 for(x=0; x<start_x; x++){
2553 buf[x + y*linesize]= buf[start_x + y*linesize];
2554 }
2555
2556 //right
2557 for(x=end_x; x<block_w; x++){
2558 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2559 }
2560 }
2561 }
2562
2563 static inline int hpel_motion(MpegEncContext *s,
2564 uint8_t *dest, uint8_t *src,
2565 int field_based, int field_select,
2566 int src_x, int src_y,
2567 int width, int height, int stride,
2568 int h_edge_pos, int v_edge_pos,
2569 int w, int h, op_pixels_func *pix_op,
2570 int motion_x, int motion_y)
2571 {
2572 int dxy;
2573 int emu=0;
2574
2575 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2576 src_x += motion_x >> 1;
2577 src_y += motion_y >> 1;
2578
2579 /* WARNING: do no forget half pels */
2580 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2581 if (src_x == width)
2582 dxy &= ~1;
2583 src_y = clip(src_y, -16, height);
2584 if (src_y == height)
2585 dxy &= ~2;
2586 src += src_y * stride + src_x;
2587
2588 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2589 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2590 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2591 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2592 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2593 src= s->edge_emu_buffer;
2594 emu=1;
2595 }
2596 }
2597 if(field_select)
2598 src += s->linesize;
2599 pix_op[dxy](dest, src, stride, h);
2600 return emu;
2601 }
2602
2603 static inline int hpel_motion_lowres(MpegEncContext *s,
2604 uint8_t *dest, uint8_t *src,
2605 int field_based, int field_select,
2606 int src_x, int src_y,
2607 int width, int height, int stride,
2608 int h_edge_pos, int v_edge_pos,
2609 int w, int h, h264_chroma_mc_func *pix_op,
2610 int motion_x, int motion_y)
2611 {
2612 const int lowres= s->avctx->lowres;
2613 const int s_mask= (2<<lowres)-1;
2614 int emu=0;
2615 int sx, sy;
2616
2617 if(s->quarter_sample){
2618 motion_x/=2;
2619 motion_y/=2;
2620 }
2621
2622 sx= motion_x & s_mask;
2623 sy= motion_y & s_mask;
2624 src_x += motion_x >> (lowres+1);
2625 src_y += motion_y >> (lowres+1);
2626
2627 src += src_y * stride + src_x;
2628
2629 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2630 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2631 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2632 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2633 src= s->edge_emu_buffer;
2634 emu=1;
2635 }
2636
2637 sx <<= 2 - lowres;
2638 sy <<= 2 - lowres;
2639 if(field_select)
2640 src += s->linesize;
2641 pix_op[lowres](dest, src, stride, h, sx, sy);
2642 return emu;
2643 }
2644
2645 /* apply one mpeg motion vector to the three components */
2646 static always_inline void mpeg_motion(MpegEncContext *s,
2647 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2648 int field_based, int bottom_field, int field_select,
2649 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2650 int motion_x, int motion_y, int h)
2651 {
2652 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2653 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2654
2655 #if 0
2656 if(s->quarter_sample)
2657 {
2658 motion_x>>=1;
2659 motion_y>>=1;
2660 }
2661 #endif
2662
2663 v_edge_pos = s->v_edge_pos >> field_based;
2664 linesize = s->current_picture.linesize[0] << field_based;
2665 uvlinesize = s->current_picture.linesize[1] << field_based;
2666
2667 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2668 src_x = s->mb_x* 16 + (motion_x >> 1);
2669 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2670
2671 if (s->out_format == FMT_H263) {
2672 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2673 mx = (motion_x>>1)|(motion_x&1);
2674 my = motion_y >>1;
2675 uvdxy = ((my & 1) << 1) | (mx & 1);
2676 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2677 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2678 }else{
2679 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2680 uvsrc_x = src_x>>1;
2681 uvsrc_y = src_y>>1;
2682 }
2683 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2684 mx = motion_x / 4;
2685 my = motion_y / 4;
2686 uvdxy = 0;
2687 uvsrc_x = s->mb_x*8 + mx;
2688 uvsrc_y = s->mb_y*8 + my;
2689 } else {
2690 if(s->chroma_y_shift){
2691 mx = motion_x / 2;
2692 my = motion_y / 2;
2693 uvdxy = ((my & 1) << 1) | (mx & 1);
2694 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2695 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2696 } else {
2697 if(s->chroma_x_shift){
2698 //Chroma422
2699 mx = motion_x / 2;
2700 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2701 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2702 uvsrc_y = src_y;
2703 } else {
2704 //Chroma444
2705 uvdxy = dxy;
2706 uvsrc_x = src_x;
2707 uvsrc_y = src_y;
2708 }
2709 }
2710 }
2711
2712 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2713 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2714 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2715
2716 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2717 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2718 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2719 s->codec_id == CODEC_ID_MPEG1VIDEO){
2720 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2721 return ;
2722 }
2723 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2724 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2725 ptr_y = s->edge_emu_buffer;
2726 if(!(s->flags&CODEC_FLAG_GRAY)){
2727 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2728 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2729 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2730 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2731 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2732 ptr_cb= uvbuf;
2733 ptr_cr= uvbuf+16;
2734 }
2735 }
2736
2737 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2738 dest_y += s->linesize;
2739 dest_cb+= s->uvlinesize;
2740 dest_cr+= s->uvlinesize;
2741 }
2742
2743 if(field_select){
2744 ptr_y += s->linesize;
2745 ptr_cb+= s->uvlinesize;
2746 ptr_cr+= s->uvlinesize;
2747 }
2748
2749 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2750
2751 if(!(s->flags&CODEC_FLAG_GRAY)){
2752 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2753 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2754 }
2755 if(s->out_format == FMT_H261){
2756 ff_h261_loop_filter(s);
2757 }
2758 }
2759
2760 /* apply one mpeg motion vector to the three components */
2761 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2762 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2763 int field_based, int bottom_field, int field_select,
2764 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2765 int motion_x, int motion_y, int h)
2766 {
2767 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2768 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2769 const int lowres= s->avctx->lowres;
2770 const int block_s= 8>>lowres;
2771 const int s_mask= (2<<lowres)-1;
2772 const int h_edge_pos = s->h_edge_pos >> lowres;
2773 const int v_edge_pos = s->v_edge_pos >> lowres;
2774 linesize = s->current_picture.linesize[0] << field_based;
2775 uvlinesize = s->current_picture.linesize[1] << field_based;
2776
2777 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2778 motion_x/=2;
2779 motion_y/=2;
2780 }
2781
2782 if(field_based){
2783 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2784 }
2785
2786 sx= motion_x & s_mask;
2787 sy= motion_y & s_mask;
2788 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2789 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2790
2791 if (s->out_format == FMT_H263) {
2792 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2793 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2794 uvsrc_x = src_x>>1;
2795 uvsrc_y = src_y>>1;
2796 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2797 mx = motion_x / 4;
2798 my = motion_y / 4;
2799 uvsx = (2*mx) & s_mask;
2800 uvsy = (2*my) & s_mask;
2801 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2802 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2803 } else {
2804 mx = motion_x / 2;
2805 my = motion_y / 2;
2806 uvsx = mx & s_mask;
2807 uvsy = my & s_mask;
2808 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2809 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2810 }
2811
2812 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2813 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2814 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;