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>
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
25 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "mpegvideo.h"
35 #include "fastmemcpy.h"
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
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);
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
74 /* enable all paranoid tests for rounding, overflows, etc... */
80 /* for jpeg fast DCT */
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
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,
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
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];
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
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)
117 for(qscale=qmin; qscale<=qmax; qscale++){
119 if (dsp->fdct == ff_jpeg_fdct_islow
120 #ifdef FAAN_POSTSCALE
121 || dsp->fdct == ff_faandct
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 */
131 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 (qscale * quant_matrix[j]));
134 } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136 || dsp->fdct == ff_faandct
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 */
146 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 (aanscales[i] * qscale * quant_matrix[j]));
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
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]);
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]);
166 for(i=intra; i<64; i++){
168 if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170 || dsp->fdct == ff_faandct
173 max= (8191LL*aanscales[i]) >> 14;
175 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
181 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
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);
189 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
191 #endif //CONFIG_ENCODERS
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
197 st->scantable= src_scantable;
201 j = src_scantable[i];
202 st->permutated[i] = permutation[j];
211 j = st->permutated[i];
213 st->raster_end[i]= end;
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
224 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
229 #endif //CONFIG_ENCODERS
231 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
239 uint32_t tmp= *state << 8;
240 *state= tmp + *(p++);
241 if(tmp == 0x100 || p==end)
246 if (p[-1] > 1 ) p+= 3;
247 else if(p[-2] ) p+= 2;
248 else if(p[-3]|(p[-1]-1)) p++;
256 *state= be2me_32(unaligned32(p));
261 /* init common dct for both encoder and decoder */
262 int DCT_common_init(MpegEncContext *s)
264 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
265 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
266 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
267 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
268 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
269 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
271 #ifdef CONFIG_ENCODERS
272 s->dct_quantize= dct_quantize_c;
273 s->denoise_dct= denoise_dct_c;
274 #endif //CONFIG_ENCODERS
277 MPV_common_init_mmx(s);
280 MPV_common_init_axp(s);
283 MPV_common_init_mlib(s);
286 MPV_common_init_mmi(s);
289 MPV_common_init_armv4l(s);
292 MPV_common_init_ppc(s);
295 #ifdef CONFIG_ENCODERS
296 s->fast_dct_quantize= s->dct_quantize;
298 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
299 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
302 #endif //CONFIG_ENCODERS
304 /* load & permutate scantables
305 note: only wmv uses different ones
307 if(s->alternate_scan){
308 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
309 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
311 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
312 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
314 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
320 static void copy_picture(Picture *dst, Picture *src){
322 dst->type= FF_BUFFER_TYPE_COPY;
325 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
328 dst->pict_type = src->pict_type;
329 dst->quality = src->quality;
330 dst->coded_picture_number = src->coded_picture_number;
331 dst->display_picture_number = src->display_picture_number;
332 // dst->reference = src->reference;
334 dst->interlaced_frame = src->interlaced_frame;
335 dst->top_field_first = src->top_field_first;
337 if(s->avctx->me_threshold){
338 if(!src->motion_val[0])
339 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
341 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
342 if(!src->ref_index[0])
343 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
344 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
345 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
346 src->motion_subsample_log2, dst->motion_subsample_log2);
348 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
351 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
352 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
354 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
355 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
357 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
358 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
365 * allocates a Picture
366 * The pixels are allocated/set by calling get_buffer() if shared=0
368 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
369 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
370 const int mb_array_size= s->mb_stride*s->mb_height;
371 const int b8_array_size= s->b8_stride*s->mb_height*2;
372 const int b4_array_size= s->b4_stride*s->mb_height*4;
376 assert(pic->data[0]);
377 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
378 pic->type= FF_BUFFER_TYPE_SHARED;
382 assert(!pic->data[0]);
384 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
386 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
387 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
391 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
392 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
396 if(pic->linesize[1] != pic->linesize[2]){
397 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
401 s->linesize = pic->linesize[0];
402 s->uvlinesize= pic->linesize[1];
405 if(pic->qscale_table==NULL){
407 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
408 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
409 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
412 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
413 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
414 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
415 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
416 if(s->out_format == FMT_H264){
418 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
419 pic->motion_val[i]= pic->motion_val_base[i]+4;
420 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
422 pic->motion_subsample_log2= 2;
423 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
425 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
426 pic->motion_val[i]= pic->motion_val_base[i]+4;
427 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
429 pic->motion_subsample_log2= 3;
431 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
432 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
434 pic->qstride= s->mb_stride;
435 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
438 //it might be nicer if the application would keep track of these but it would require a API change
439 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
440 s->prev_pict_types[0]= s->pict_type;
441 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
442 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
445 fail: //for the CHECKED_ALLOCZ macro
450 * deallocates a picture
452 static void free_picture(MpegEncContext *s, Picture *pic){
455 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
456 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
459 av_freep(&pic->mb_var);
460 av_freep(&pic->mc_mb_var);
461 av_freep(&pic->mb_mean);
462 av_freep(&pic->mbskip_table);
463 av_freep(&pic->qscale_table);
464 av_freep(&pic->mb_type_base);
465 av_freep(&pic->dct_coeff);
466 av_freep(&pic->pan_scan);
469 av_freep(&pic->motion_val_base[i]);
470 av_freep(&pic->ref_index[i]);
473 if(pic->type == FF_BUFFER_TYPE_SHARED){
482 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
485 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
486 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
487 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
489 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
490 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
491 s->rd_scratchpad= s->me.scratchpad;
492 s->b_scratchpad= s->me.scratchpad;
493 s->obmc_scratchpad= s->me.scratchpad + 16;
495 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
496 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
497 if(s->avctx->noise_reduction){
498 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
501 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
502 s->block= s->blocks[0];
505 s->pblocks[i] = (short *)(&s->block[i]);
509 return -1; //free() through MPV_common_end()
512 static void free_duplicate_context(MpegEncContext *s){
515 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
516 av_freep(&s->me.scratchpad);
519 s->obmc_scratchpad= NULL;
521 av_freep(&s->dct_error_sum);
522 av_freep(&s->me.map);
523 av_freep(&s->me.score_map);
524 av_freep(&s->blocks);
528 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
529 #define COPY(a) bak->a= src->a
530 COPY(allocated_edge_emu_buffer);
531 COPY(edge_emu_buffer);
535 COPY(obmc_scratchpad);
542 COPY(me.map_generation);
550 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
553 //FIXME copy only needed parts
555 backup_duplicate_context(&bak, dst);
556 memcpy(dst, src, sizeof(MpegEncContext));
557 backup_duplicate_context(dst, &bak);
559 dst->pblocks[i] = (short *)(&dst->block[i]);
561 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
564 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
565 #define COPY(a) dst->a= src->a
567 COPY(current_picture);
573 COPY(picture_in_gop_number);
574 COPY(gop_picture_number);
575 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
576 COPY(progressive_frame); //FIXME don't set in encode_header
577 COPY(partitioned_frame); //FIXME don't set in encode_header
582 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
583 * the changed fields will not depend upon the prior state of the MpegEncContext.
585 static void MPV_common_defaults(MpegEncContext *s){
587 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
588 s->chroma_qscale_table= ff_default_chroma_qscale_table;
589 s->progressive_frame= 1;
590 s->progressive_sequence= 1;
591 s->picture_structure= PICT_FRAME;
593 s->coded_picture_number = 0;
594 s->picture_number = 0;
595 s->input_picture_number = 0;
597 s->picture_in_gop_number = 0;
604 * sets the given MpegEncContext to defaults for decoding.
605 * the changed fields will not depend upon the prior state of the MpegEncContext.
607 void MPV_decode_defaults(MpegEncContext *s){
608 MPV_common_defaults(s);
612 * sets the given MpegEncContext to defaults for encoding.
613 * the changed fields will not depend upon the prior state of the MpegEncContext.
616 #ifdef CONFIG_ENCODERS
617 static void MPV_encode_defaults(MpegEncContext *s){
620 MPV_common_defaults(s);
626 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
627 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
629 for(i=-16; i<16; i++){
630 default_fcode_tab[i + MAX_MV]= 1;
633 s->me.mv_penalty= default_mv_penalty;
634 s->fcode_tab= default_fcode_tab;
636 #endif //CONFIG_ENCODERS
639 * init common structure for both encoder and decoder.
640 * this assumes that some variables like width/height are already set
642 int MPV_common_init(MpegEncContext *s)
644 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
646 s->mb_height = (s->height + 15) / 16;
648 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
649 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
653 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
656 dsputil_init(&s->dsp, s->avctx);
659 s->flags= s->avctx->flags;
660 s->flags2= s->avctx->flags2;
662 s->mb_width = (s->width + 15) / 16;
663 s->mb_stride = s->mb_width + 1;
664 s->b8_stride = s->mb_width*2 + 1;
665 s->b4_stride = s->mb_width*4 + 1;
666 mb_array_size= s->mb_height * s->mb_stride;
667 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
669 /* set chroma shifts */
670 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
671 &(s->chroma_y_shift) );
673 /* set default edge pos, will be overriden in decode_header if needed */
674 s->h_edge_pos= s->mb_width*16;
675 s->v_edge_pos= s->mb_height*16;
677 s->mb_num = s->mb_width * s->mb_height;
682 s->block_wrap[3]= s->b8_stride;
684 s->block_wrap[5]= s->mb_stride;
686 y_size = s->b8_stride * (2 * s->mb_height + 1);
687 c_size = s->mb_stride * (s->mb_height + 1);
688 yc_size = y_size + 2 * c_size;
690 /* convert fourcc to upper case */
691 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
692 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
693 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
694 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
696 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
697 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
698 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
699 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
701 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
703 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
704 for(y=0; y<s->mb_height; y++){
705 for(x=0; x<s->mb_width; x++){
706 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
709 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
712 /* Allocate MV tables */
713 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
714 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
715 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
716 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
717 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
718 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
719 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
720 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
721 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
722 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
723 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
724 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
726 if(s->msmpeg4_version){
727 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
729 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
731 /* Allocate MB type table */
732 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
734 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
736 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
737 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
738 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
739 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
740 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
741 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
743 if(s->avctx->noise_reduction){
744 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
747 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
749 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
751 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
752 /* interlaced direct mode decoding tables */
757 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
758 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
760 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
761 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
762 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
764 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
767 if (s->out_format == FMT_H263) {
769 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
770 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
771 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
772 s->ac_val[2] = s->ac_val[1] + c_size;
775 CHECKED_ALLOCZ(s->coded_block_base, y_size);
776 s->coded_block= s->coded_block_base + s->b8_stride + 1;
778 /* cbp, ac_pred, pred_dir */
779 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
780 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
783 if (s->h263_pred || s->h263_plus || !s->encoding) {
785 //MN: we need these for error resilience of intra-frames
786 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
787 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
788 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
789 s->dc_val[2] = s->dc_val[1] + c_size;
790 for(i=0;i<yc_size;i++)
791 s->dc_val_base[i] = 1024;
794 /* which mb is a intra block */
795 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
796 memset(s->mbintra_table, 1, mb_array_size);
798 /* init macroblock skip table */
799 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
800 //Note the +1 is for a quicker mpeg4 slice_end detection
801 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
803 s->parse_context.state= -1;
804 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
805 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
806 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
807 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
810 s->context_initialized = 1;
812 s->thread_context[0]= s;
813 for(i=1; i<s->avctx->thread_count; i++){
814 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
815 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
818 for(i=0; i<s->avctx->thread_count; i++){
819 if(init_duplicate_context(s->thread_context[i], s) < 0)
821 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
822 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
831 /* init common structure for both encoder and decoder */
832 void MPV_common_end(MpegEncContext *s)
836 for(i=0; i<s->avctx->thread_count; i++){
837 free_duplicate_context(s->thread_context[i]);
839 for(i=1; i<s->avctx->thread_count; i++){
840 av_freep(&s->thread_context[i]);
843 av_freep(&s->parse_context.buffer);
844 s->parse_context.buffer_size=0;
846 av_freep(&s->mb_type);
847 av_freep(&s->p_mv_table_base);
848 av_freep(&s->b_forw_mv_table_base);
849 av_freep(&s->b_back_mv_table_base);
850 av_freep(&s->b_bidir_forw_mv_table_base);
851 av_freep(&s->b_bidir_back_mv_table_base);
852 av_freep(&s->b_direct_mv_table_base);
854 s->b_forw_mv_table= NULL;
855 s->b_back_mv_table= NULL;
856 s->b_bidir_forw_mv_table= NULL;
857 s->b_bidir_back_mv_table= NULL;
858 s->b_direct_mv_table= NULL;
862 av_freep(&s->b_field_mv_table_base[i][j][k]);
863 s->b_field_mv_table[i][j][k]=NULL;
865 av_freep(&s->b_field_select_table[i][j]);
866 av_freep(&s->p_field_mv_table_base[i][j]);
867 s->p_field_mv_table[i][j]=NULL;
869 av_freep(&s->p_field_select_table[i]);
872 av_freep(&s->dc_val_base);
873 av_freep(&s->ac_val_base);
874 av_freep(&s->coded_block_base);
875 av_freep(&s->mbintra_table);
876 av_freep(&s->cbp_table);
877 av_freep(&s->pred_dir_table);
879 av_freep(&s->mbskip_table);
880 av_freep(&s->prev_pict_types);
881 av_freep(&s->bitstream_buffer);
882 s->allocated_bitstream_buffer_size=0;
884 av_freep(&s->avctx->stats_out);
885 av_freep(&s->ac_stats);
886 av_freep(&s->error_status_table);
887 av_freep(&s->mb_index2xy);
888 av_freep(&s->lambda_table);
889 av_freep(&s->q_intra_matrix);
890 av_freep(&s->q_inter_matrix);
891 av_freep(&s->q_intra_matrix16);
892 av_freep(&s->q_inter_matrix16);
893 av_freep(&s->input_picture);
894 av_freep(&s->reordered_input_picture);
895 av_freep(&s->dct_offset);
898 for(i=0; i<MAX_PICTURE_COUNT; i++){
899 free_picture(s, &s->picture[i]);
902 av_freep(&s->picture);
903 s->context_initialized = 0;
906 s->current_picture_ptr= NULL;
907 s->linesize= s->uvlinesize= 0;
910 av_freep(&s->visualization_buffer[i]);
912 avcodec_default_free_buffers(s->avctx);
915 #ifdef CONFIG_ENCODERS
917 /* init video encoder */
918 int MPV_encode_init(AVCodecContext *avctx)
920 MpegEncContext *s = avctx->priv_data;
922 int chroma_h_shift, chroma_v_shift;
924 MPV_encode_defaults(s);
926 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
927 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
931 if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
932 if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
933 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
937 if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
938 av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
943 s->bit_rate = avctx->bit_rate;
944 s->width = avctx->width;
945 s->height = avctx->height;
946 if(avctx->gop_size > 600){
947 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
950 s->gop_size = avctx->gop_size;
952 s->flags= avctx->flags;
953 s->flags2= avctx->flags2;
954 s->max_b_frames= avctx->max_b_frames;
955 s->codec_id= avctx->codec->id;
956 s->luma_elim_threshold = avctx->luma_elim_threshold;
957 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
958 s->strict_std_compliance= avctx->strict_std_compliance;
959 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
960 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
961 s->mpeg_quant= avctx->mpeg_quant;
962 s->rtp_mode= !!avctx->rtp_payload_size;
963 s->intra_dc_precision= avctx->intra_dc_precision;
964 s->user_specified_pts = AV_NOPTS_VALUE;
966 if (s->gop_size <= 1) {
973 s->me_method = avctx->me_method;
976 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
978 s->adaptive_quant= ( s->avctx->lumi_masking
979 || s->avctx->dark_masking
980 || s->avctx->temporal_cplx_masking
981 || s->avctx->spatial_cplx_masking
982 || s->avctx->p_masking
983 || s->avctx->border_masking
984 || (s->flags&CODEC_FLAG_QP_RD))
987 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
988 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
989 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
991 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
992 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
996 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
997 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1000 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1001 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1005 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1006 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1010 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1011 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1012 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1014 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
1017 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1018 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1019 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1023 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1024 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1028 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1029 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1033 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1034 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1038 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1039 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1043 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1044 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1048 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1049 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1050 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1054 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1055 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1059 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1060 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1064 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1065 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1069 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1070 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1074 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1075 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1076 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1077 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1081 if(s->avctx->thread_count > 1)
1084 if(!avctx->time_base.den || !avctx->time_base.num){
1085 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1089 i= (INT_MAX/2+128)>>8;
1090 if(avctx->me_threshold >= i){
1091 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1094 if(avctx->mb_threshold >= i){
1095 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1099 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1100 av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass\n");
1104 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1106 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1107 avctx->time_base.den /= i;
1108 avctx->time_base.num /= i;
1112 if(s->codec_id==CODEC_ID_MJPEG){
1113 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1114 s->inter_quant_bias= 0;
1115 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1116 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1117 s->inter_quant_bias= 0;
1119 s->intra_quant_bias=0;
1120 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1123 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1124 s->intra_quant_bias= avctx->intra_quant_bias;
1125 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1126 s->inter_quant_bias= avctx->inter_quant_bias;
1128 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1130 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1131 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1134 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1136 switch(avctx->codec->id) {
1137 case CODEC_ID_MPEG1VIDEO:
1138 s->out_format = FMT_MPEG1;
1139 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1140 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1142 case CODEC_ID_MPEG2VIDEO:
1143 s->out_format = FMT_MPEG1;
1144 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1145 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1148 case CODEC_ID_LJPEG:
1149 case CODEC_ID_JPEGLS:
1150 case CODEC_ID_MJPEG:
1151 s->out_format = FMT_MJPEG;
1152 s->intra_only = 1; /* force intra only for jpeg */
1153 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1154 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1155 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1156 s->mjpeg_vsample[1] = 1;
1157 s->mjpeg_vsample[2] = 1;
1158 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1159 s->mjpeg_hsample[1] = 1;
1160 s->mjpeg_hsample[2] = 1;
1161 if (mjpeg_init(s) < 0)
1167 s->out_format = FMT_H261;
1172 if (h263_get_picture_format(s->width, s->height) == 7) {
1173 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
1176 s->out_format = FMT_H263;
1177 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1181 case CODEC_ID_H263P:
1182 s->out_format = FMT_H263;
1185 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1186 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1187 s->modified_quant= s->h263_aic;
1188 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1189 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1190 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1191 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1192 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1195 /* These are just to be sure */
1200 s->out_format = FMT_H263;
1201 s->h263_flv = 2; /* format = 1; 11-bit codes */
1202 s->unrestricted_mv = 1;
1203 s->rtp_mode=0; /* don't allow GOB */
1208 s->out_format = FMT_H263;
1213 s->out_format = FMT_H263;
1216 s->modified_quant=1;
1220 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1222 case CODEC_ID_MPEG4:
1223 s->out_format = FMT_H263;
1225 s->unrestricted_mv = 1;
1226 s->low_delay= s->max_b_frames ? 0 : 1;
1227 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1229 case CODEC_ID_MSMPEG4V1:
1230 s->out_format = FMT_H263;
1231 s->h263_msmpeg4 = 1;
1233 s->unrestricted_mv = 1;
1234 s->msmpeg4_version= 1;
1238 case CODEC_ID_MSMPEG4V2:
1239 s->out_format = FMT_H263;
1240 s->h263_msmpeg4 = 1;
1242 s->unrestricted_mv = 1;
1243 s->msmpeg4_version= 2;
1247 case CODEC_ID_MSMPEG4V3:
1248 s->out_format = FMT_H263;
1249 s->h263_msmpeg4 = 1;
1251 s->unrestricted_mv = 1;
1252 s->msmpeg4_version= 3;
1253 s->flipflop_rounding=1;
1258 s->out_format = FMT_H263;
1259 s->h263_msmpeg4 = 1;
1261 s->unrestricted_mv = 1;
1262 s->msmpeg4_version= 4;
1263 s->flipflop_rounding=1;
1268 s->out_format = FMT_H263;
1269 s->h263_msmpeg4 = 1;
1271 s->unrestricted_mv = 1;
1272 s->msmpeg4_version= 5;
1273 s->flipflop_rounding=1;
1281 avctx->has_b_frames= !s->low_delay;
1286 if (MPV_common_init(s) < 0)
1289 if(s->modified_quant)
1290 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1291 s->progressive_frame=
1292 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1293 s->quant_precision=5;
1295 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1296 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1298 #ifdef CONFIG_H261_ENCODER
1299 if (s->out_format == FMT_H261)
1300 ff_h261_encode_init(s);
1302 if (s->out_format == FMT_H263)
1303 h263_encode_init(s);
1304 if(s->msmpeg4_version)
1305 ff_msmpeg4_encode_init(s);
1306 if (s->out_format == FMT_MPEG1)
1307 ff_mpeg1_encode_init(s);
1311 int j= s->dsp.idct_permutation[i];
1312 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1313 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1314 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1315 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1316 s->intra_matrix[j] =
1317 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1320 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1321 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1323 if(s->avctx->intra_matrix)
1324 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1325 if(s->avctx->inter_matrix)
1326 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1329 /* precompute matrix */
1330 /* for mjpeg, we do include qscale in the matrix */
1331 if (s->out_format != FMT_MJPEG) {
1332 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1333 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1334 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1335 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1338 if(ff_rate_control_init(s) < 0)
1344 int MPV_encode_end(AVCodecContext *avctx)
1346 MpegEncContext *s = avctx->priv_data;
1352 ff_rate_control_uninit(s);
1355 if (s->out_format == FMT_MJPEG)
1358 av_freep(&avctx->extradata);
1363 #endif //CONFIG_ENCODERS
1365 void init_rl(RLTable *rl, int use_static)
1367 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1368 uint8_t index_run[MAX_RUN+1];
1369 int last, run, level, start, end, i;
1371 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1372 if(use_static && rl->max_level[0])
1375 /* compute max_level[], max_run[] and index_run[] */
1376 for(last=0;last<2;last++) {
1385 memset(max_level, 0, MAX_RUN + 1);
1386 memset(max_run, 0, MAX_LEVEL + 1);
1387 memset(index_run, rl->n, MAX_RUN + 1);
1388 for(i=start;i<end;i++) {
1389 run = rl->table_run[i];
1390 level = rl->table_level[i];
1391 if (index_run[run] == rl->n)
1393 if (level > max_level[run])
1394 max_level[run] = level;
1395 if (run > max_run[level])
1396 max_run[level] = run;
1399 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1401 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1402 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1404 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1406 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1407 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1409 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1411 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1412 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1416 /* draw the edges of width 'w' of an image of size width, height */
1417 //FIXME check that this is ok for mpeg4 interlaced
1418 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1420 uint8_t *ptr, *last_line;
1423 last_line = buf + (height - 1) * wrap;
1425 /* top and bottom */
1426 memcpy(buf - (i + 1) * wrap, buf, width);
1427 memcpy(last_line + (i + 1) * wrap, last_line, width);
1429 /* left and right */
1431 for(i=0;i<height;i++) {
1432 memset(ptr - w, ptr[0], w);
1433 memset(ptr + width, ptr[width-1], w);
1438 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1439 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1440 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1441 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1445 int ff_find_unused_picture(MpegEncContext *s, int shared){
1449 for(i=0; i<MAX_PICTURE_COUNT; i++){
1450 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1453 for(i=0; i<MAX_PICTURE_COUNT; i++){
1454 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1456 for(i=0; i<MAX_PICTURE_COUNT; i++){
1457 if(s->picture[i].data[0]==NULL) return i;
1465 static void update_noise_reduction(MpegEncContext *s){
1468 for(intra=0; intra<2; intra++){
1469 if(s->dct_count[intra] > (1<<16)){
1470 for(i=0; i<64; i++){
1471 s->dct_error_sum[intra][i] >>=1;
1473 s->dct_count[intra] >>= 1;
1476 for(i=0; i<64; i++){
1477 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1483 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1485 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1491 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1493 /* mark&release old frames */
1494 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1495 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1497 /* release forgotten pictures */
1498 /* if(mpeg124/h263) */
1500 for(i=0; i<MAX_PICTURE_COUNT; i++){
1501 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1502 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1503 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1510 /* release non reference frames */
1511 for(i=0; i<MAX_PICTURE_COUNT; i++){
1512 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1513 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1517 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1518 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1520 i= ff_find_unused_picture(s, 0);
1521 pic= (AVFrame*)&s->picture[i];
1524 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1525 && !s->dropable ? 3 : 0;
1527 pic->coded_picture_number= s->coded_picture_number++;
1529 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1532 s->current_picture_ptr= (Picture*)pic;
1533 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1534 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1537 s->current_picture_ptr->pict_type= s->pict_type;
1538 // if(s->flags && CODEC_FLAG_QSCALE)
1539 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1540 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1542 copy_picture(&s->current_picture, s->current_picture_ptr);
1544 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1545 if (s->pict_type != B_TYPE) {
1546 s->last_picture_ptr= s->next_picture_ptr;
1548 s->next_picture_ptr= s->current_picture_ptr;
1550 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1551 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1552 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1553 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1554 s->pict_type, s->dropable);*/
1556 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1557 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1559 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1560 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1561 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1565 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1567 if(s->picture_structure!=PICT_FRAME){
1570 if(s->picture_structure == PICT_BOTTOM_FIELD){
1571 s->current_picture.data[i] += s->current_picture.linesize[i];
1573 s->current_picture.linesize[i] *= 2;
1574 s->last_picture.linesize[i] *=2;
1575 s->next_picture.linesize[i] *=2;
1580 s->hurry_up= s->avctx->hurry_up;
1581 s->error_resilience= avctx->error_resilience;
1583 /* set dequantizer, we can't do it during init as it might change for mpeg4
1584 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1585 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1586 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1587 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1588 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1589 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1590 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1592 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1593 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1596 if(s->dct_error_sum){
1597 assert(s->avctx->noise_reduction && s->encoding);
1599 update_noise_reduction(s);
1603 if(s->avctx->xvmc_acceleration)
1604 return XVMC_field_start(s, avctx);
1609 /* generic function for encode/decode called after a frame has been coded/decoded */
1610 void MPV_frame_end(MpegEncContext *s)
1613 /* draw edge for correct motion prediction if outside */
1615 //just to make sure that all data is rendered.
1616 if(s->avctx->xvmc_acceleration){
1620 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1621 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1622 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1623 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1627 s->last_pict_type = s->pict_type;
1628 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1629 if(s->pict_type!=B_TYPE){
1630 s->last_non_b_pict_type= s->pict_type;
1633 /* copy back current_picture variables */
1634 for(i=0; i<MAX_PICTURE_COUNT; i++){
1635 if(s->picture[i].data[0] == s->current_picture.data[0]){
1636 s->picture[i]= s->current_picture;
1640 assert(i<MAX_PICTURE_COUNT);
1644 /* release non-reference frames */
1645 for(i=0; i<MAX_PICTURE_COUNT; i++){
1646 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1647 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1651 // clear copies, to avoid confusion
1653 memset(&s->last_picture, 0, sizeof(Picture));
1654 memset(&s->next_picture, 0, sizeof(Picture));
1655 memset(&s->current_picture, 0, sizeof(Picture));
1657 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1661 * draws an line from (ex, ey) -> (sx, sy).
1662 * @param w width of the image
1663 * @param h height of the image
1664 * @param stride stride/linesize of the image
1665 * @param color color of the arrow
1667 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1670 sx= clip(sx, 0, w-1);
1671 sy= clip(sy, 0, h-1);
1672 ex= clip(ex, 0, w-1);
1673 ey= clip(ey, 0, h-1);
1675 buf[sy*stride + sx]+= color;
1677 if(ABS(ex - sx) > ABS(ey - sy)){
1682 buf+= sx + sy*stride;
1684 f= ((ey-sy)<<16)/ex;
1685 for(x= 0; x <= ex; x++){
1688 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1689 buf[(y+1)*stride + x]+= (color* fr )>>16;
1696 buf+= sx + sy*stride;
1698 if(ey) f= ((ex-sx)<<16)/ey;
1700 for(y= 0; y <= ey; y++){
1703 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1704 buf[y*stride + x+1]+= (color* fr )>>16;;
1710 * draws an arrow from (ex, ey) -> (sx, sy).
1711 * @param w width of the image
1712 * @param h height of the image
1713 * @param stride stride/linesize of the image
1714 * @param color color of the arrow
1716 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1719 sx= clip(sx, -100, w+100);
1720 sy= clip(sy, -100, h+100);
1721 ex= clip(ex, -100, w+100);
1722 ey= clip(ey, -100, h+100);
1727 if(dx*dx + dy*dy > 3*3){
1730 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1732 //FIXME subpixel accuracy
1733 rx= ROUNDED_DIV(rx*3<<4, length);
1734 ry= ROUNDED_DIV(ry*3<<4, length);
1736 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1737 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1739 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1743 * prints debuging info for the given picture.
1745 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1747 if(!pict || !pict->mb_type) return;
1749 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1752 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1753 switch (pict->pict_type) {
1754 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1755 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1756 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1757 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1758 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1759 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1761 for(y=0; y<s->mb_height; y++){
1762 for(x=0; x<s->mb_width; x++){
1763 if(s->avctx->debug&FF_DEBUG_SKIP){
1764 int count= s->mbskip_table[x + y*s->mb_stride];
1765 if(count>9) count=9;
1766 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1768 if(s->avctx->debug&FF_DEBUG_QP){
1769 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1771 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1772 int mb_type= pict->mb_type[x + y*s->mb_stride];
1773 //Type & MV direction
1775 av_log(s->avctx, AV_LOG_DEBUG, "P");
1776 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1777 av_log(s->avctx, AV_LOG_DEBUG, "A");
1778 else if(IS_INTRA4x4(mb_type))
1779 av_log(s->avctx, AV_LOG_DEBUG, "i");
1780 else if(IS_INTRA16x16(mb_type))
1781 av_log(s->avctx, AV_LOG_DEBUG, "I");
1782 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1783 av_log(s->avctx, AV_LOG_DEBUG, "d");
1784 else if(IS_DIRECT(mb_type))
1785 av_log(s->avctx, AV_LOG_DEBUG, "D");
1786 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1787 av_log(s->avctx, AV_LOG_DEBUG, "g");
1788 else if(IS_GMC(mb_type))
1789 av_log(s->avctx, AV_LOG_DEBUG, "G");
1790 else if(IS_SKIP(mb_type))
1791 av_log(s->avctx, AV_LOG_DEBUG, "S");
1792 else if(!USES_LIST(mb_type, 1))
1793 av_log(s->avctx, AV_LOG_DEBUG, ">");
1794 else if(!USES_LIST(mb_type, 0))
1795 av_log(s->avctx, AV_LOG_DEBUG, "<");
1797 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1798 av_log(s->avctx, AV_LOG_DEBUG, "X");
1803 av_log(s->avctx, AV_LOG_DEBUG, "+");
1804 else if(IS_16X8(mb_type))
1805 av_log(s->avctx, AV_LOG_DEBUG, "-");
1806 else if(IS_8X16(mb_type))
1807 av_log(s->avctx, AV_LOG_DEBUG, "|");
1808 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1809 av_log(s->avctx, AV_LOG_DEBUG, " ");
1811 av_log(s->avctx, AV_LOG_DEBUG, "?");
1814 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1815 av_log(s->avctx, AV_LOG_DEBUG, "=");
1817 av_log(s->avctx, AV_LOG_DEBUG, " ");
1819 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1821 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1825 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1826 const int shift= 1 + s->quarter_sample;
1830 int h_chroma_shift, v_chroma_shift;
1831 const int width = s->avctx->width;
1832 const int height= s->avctx->height;
1833 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1834 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1835 s->low_delay=0; //needed to see the vectors without trashing the buffers
1837 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1839 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1840 pict->data[i]= s->visualization_buffer[i];
1842 pict->type= FF_BUFFER_TYPE_COPY;
1845 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1847 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1848 const int mb_index= mb_x + mb_y*s->mb_stride;
1849 if((s->avctx->debug_mv) && pict->motion_val){
1851 for(type=0; type<3; type++){
1854 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1858 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1862 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1867 if(!USES_LIST(pict->mb_type[mb_index], direction))
1870 if(IS_8X8(pict->mb_type[mb_index])){
1873 int sx= mb_x*16 + 4 + 8*(i&1);
1874 int sy= mb_y*16 + 4 + 8*(i>>1);
1875 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1876 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1877 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1878 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1880 }else if(IS_16X8(pict->mb_type[mb_index])){
1884 int sy=mb_y*16 + 4 + 8*i;
1885 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1886 int mx=(pict->motion_val[direction][xy][0]>>shift);
1887 int my=(pict->motion_val[direction][xy][1]>>shift);
1889 if(IS_INTERLACED(pict->mb_type[mb_index]))
1892 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1894 }else if(IS_8X16(pict->mb_type[mb_index])){
1897 int sx=mb_x*16 + 4 + 8*i;
1899 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1900 int mx=(pict->motion_val[direction][xy][0]>>shift);
1901 int my=(pict->motion_val[direction][xy][1]>>shift);
1903 if(IS_INTERLACED(pict->mb_type[mb_index]))
1906 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1909 int sx= mb_x*16 + 8;
1910 int sy= mb_y*16 + 8;
1911 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1912 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1913 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1914 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1918 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1919 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1922 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1923 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1926 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1927 int mb_type= pict->mb_type[mb_index];
1930 #define COLOR(theta, r)\
1931 u= (int)(128 + r*cos(theta*3.141592/180));\
1932 v= (int)(128 + r*sin(theta*3.141592/180));
1936 if(IS_PCM(mb_type)){
1938 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1940 }else if(IS_INTRA4x4(mb_type)){
1942 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1944 }else if(IS_DIRECT(mb_type)){
1946 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1948 }else if(IS_GMC(mb_type)){
1950 }else if(IS_SKIP(mb_type)){
1952 }else if(!USES_LIST(mb_type, 1)){
1954 }else if(!USES_LIST(mb_type, 0)){
1957 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1961 u*= 0x0101010101010101ULL;
1962 v*= 0x0101010101010101ULL;
1964 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1965 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1969 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1970 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1971 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1973 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1975 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1977 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1978 int dm= 1 << (mv_sample_log2-2);
1980 int sx= mb_x*16 + 8*(i&1);
1981 int sy= mb_y*16 + 8*(i>>1);
1982 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1984 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1985 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1987 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1988 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1989 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1993 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1997 s->mbskip_table[mb_index]=0;
2003 #ifdef CONFIG_ENCODERS
2005 static int get_sae(uint8_t *src, int ref, int stride){
2009 for(y=0; y<16; y++){
2010 for(x=0; x<16; x++){
2011 acc+= ABS(src[x+y*stride] - ref);
2018 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2025 for(y=0; y<h; y+=16){
2026 for(x=0; x<w; x+=16){
2027 int offset= x + y*stride;
2028 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2029 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2030 int sae = get_sae(src + offset, mean, stride);
2032 acc+= sae + 500 < sad;
2039 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2043 const int encoding_delay= s->max_b_frames;
2048 pic_arg->display_picture_number= s->input_picture_number++;
2050 if(pts != AV_NOPTS_VALUE){
2051 if(s->user_specified_pts != AV_NOPTS_VALUE){
2053 int64_t last= s->user_specified_pts;
2056 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2060 s->user_specified_pts= pts;
2062 if(s->user_specified_pts != AV_NOPTS_VALUE){
2063 s->user_specified_pts=
2064 pts= s->user_specified_pts + 1;
2065 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2067 pts= pic_arg->display_picture_number;
2073 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2074 if(pic_arg->linesize[0] != s->linesize) direct=0;
2075 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2076 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2078 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2081 i= ff_find_unused_picture(s, 1);
2083 pic= (AVFrame*)&s->picture[i];
2087 pic->data[i]= pic_arg->data[i];
2088 pic->linesize[i]= pic_arg->linesize[i];
2090 alloc_picture(s, (Picture*)pic, 1);
2092 i= ff_find_unused_picture(s, 0);
2094 pic= (AVFrame*)&s->picture[i];
2097 alloc_picture(s, (Picture*)pic, 0);
2099 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2100 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2101 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2104 int h_chroma_shift, v_chroma_shift;
2105 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2108 int src_stride= pic_arg->linesize[i];
2109 int dst_stride= i ? s->uvlinesize : s->linesize;
2110 int h_shift= i ? h_chroma_shift : 0;
2111 int v_shift= i ? v_chroma_shift : 0;
2112 int w= s->width >>h_shift;
2113 int h= s->height>>v_shift;
2114 uint8_t *src= pic_arg->data[i];
2115 uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2117 if(src_stride==dst_stride)
2118 memcpy(dst, src, src_stride*h);
2121 memcpy(dst, src, w);
2129 copy_picture_attributes(s, pic, pic_arg);
2130 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2133 /* shift buffer entries */
2134 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2135 s->input_picture[i-1]= s->input_picture[i];
2137 s->input_picture[encoding_delay]= (Picture*)pic;
2142 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2147 for(plane=0; plane<3; plane++){
2148 const int stride= p->linesize[plane];
2149 const int bw= plane ? 1 : 2;
2150 for(y=0; y<s->mb_height*bw; y++){
2151 for(x=0; x<s->mb_width*bw; x++){
2152 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2153 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2155 switch(s->avctx->frame_skip_exp){
2156 case 0: score= FFMAX(score, v); break;
2157 case 1: score+= ABS(v);break;
2158 case 2: score+= v*v;break;
2159 case 3: score64+= ABS(v*v*(int64_t)v);break;
2160 case 4: score64+= v*v*(int64_t)(v*v);break;
2166 if(score) score64= score;
2168 if(score64 < s->avctx->frame_skip_threshold)
2170 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2175 static int estimate_best_b_count(MpegEncContext *s){
2176 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2177 AVCodecContext *c= avcodec_alloc_context();
2178 AVFrame input[FF_MAX_B_FRAMES+2];
2179 const int scale= s->avctx->brd_scale;
2180 int i, j, out_size, p_lambda, b_lambda, lambda2;
2181 int outbuf_size= s->width * s->height; //FIXME
2182 uint8_t *outbuf= av_malloc(outbuf_size);
2183 ImgReSampleContext *resample;
2184 int64_t best_rd= INT64_MAX;
2185 int best_b_count= -1;
2188 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2189 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2190 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2191 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2193 c->width = s->width >> scale;
2194 c->height= s->height>> scale;
2195 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2196 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2197 c->mb_decision= s->avctx->mb_decision;
2198 c->me_cmp= s->avctx->me_cmp;
2199 c->mb_cmp= s->avctx->mb_cmp;
2200 c->me_sub_cmp= s->avctx->me_sub_cmp;
2201 c->pix_fmt = PIX_FMT_YUV420P;
2202 c->time_base= s->avctx->time_base;
2203 c->max_b_frames= s->max_b_frames;
2205 if (avcodec_open(c, codec) < 0)
2208 resample= img_resample_init(c->width, c->height, s->width, s->height); //FIXME use sws
2210 for(i=0; i<s->max_b_frames+2; i++){
2211 int ysize= c->width*c->height;
2212 int csize= (c->width/2)*(c->height/2);
2213 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2216 pre_input= *pre_input_ptr;
2218 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2219 pre_input.data[0]+=INPLACE_OFFSET;
2220 pre_input.data[1]+=INPLACE_OFFSET;
2221 pre_input.data[2]+=INPLACE_OFFSET;
2224 avcodec_get_frame_defaults(&input[i]);
2225 input[i].data[0]= av_malloc(ysize + 2*csize);
2226 input[i].data[1]= input[i].data[0] + ysize;
2227 input[i].data[2]= input[i].data[1] + csize;
2228 input[i].linesize[0]= c->width;
2229 input[i].linesize[1]=
2230 input[i].linesize[2]= c->width/2;
2232 if(!i || s->input_picture[i-1])
2233 img_resample(resample, &input[i], &pre_input);
2236 for(j=0; j<s->max_b_frames+1; j++){
2239 if(!s->input_picture[j])
2242 c->error[0]= c->error[1]= c->error[2]= 0;
2244 input[0].pict_type= I_TYPE;
2245 input[0].quality= 1 * FF_QP2LAMBDA;
2246 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2247 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2249 for(i=0; i<s->max_b_frames+1; i++){
2250 int is_p= i % (j+1) == j || i==s->max_b_frames;
2252 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2253 input[i+1].quality= is_p ? p_lambda : b_lambda;
2254 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2255 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2258 /* get the delayed frames */
2260 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2261 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2264 rd += c->error[0] + c->error[1] + c->error[2];
2275 img_resample_close(resample);
2277 for(i=0; i<s->max_b_frames+2; i++){
2278 av_freep(&input[i].data[0]);
2281 return best_b_count;
2284 static void select_input_picture(MpegEncContext *s){
2287 for(i=1; i<MAX_PICTURE_COUNT; i++)
2288 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2289 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2291 /* set next picture type & ordering */
2292 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2293 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2294 s->reordered_input_picture[0]= s->input_picture[0];
2295 s->reordered_input_picture[0]->pict_type= I_TYPE;
2296 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2300 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2301 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2302 //FIXME check that te gop check above is +-1 correct
2303 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2305 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2307 s->input_picture[0]->data[i]= NULL;
2308 s->input_picture[0]->type= 0;
2310 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2311 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2313 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2317 ff_vbv_update(s, 0);
2323 if(s->flags&CODEC_FLAG_PASS2){
2324 for(i=0; i<s->max_b_frames+1; i++){
2325 int pict_num= s->input_picture[0]->display_picture_number + i;
2327 if(pict_num >= s->rc_context.num_entries)
2329 if(!s->input_picture[i]){
2330 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2334 s->input_picture[i]->pict_type=
2335 s->rc_context.entry[pict_num].new_pict_type;
2339 if(s->avctx->b_frame_strategy==0){
2340 b_frames= s->max_b_frames;
2341 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2342 }else if(s->avctx->b_frame_strategy==1){
2343 for(i=1; i<s->max_b_frames+1; i++){
2344 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2345 s->input_picture[i]->b_frame_score=
2346 get_intra_count(s, s->input_picture[i ]->data[0],
2347 s->input_picture[i-1]->data[0], s->linesize) + 1;
2350 for(i=0; i<s->max_b_frames+1; i++){
2351 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2354 b_frames= FFMAX(0, i-1);
2357 for(i=0; i<b_frames+1; i++){
2358 s->input_picture[i]->b_frame_score=0;
2360 }else if(s->avctx->b_frame_strategy==2){
2361 b_frames= estimate_best_b_count(s);
2363 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2368 //static int b_count=0;
2369 //b_count+= b_frames;
2370 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2372 for(i= b_frames - 1; i>=0; i--){
2373 int type= s->input_picture[i]->pict_type;
2374 if(type && type != B_TYPE)
2377 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2378 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2381 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2382 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2383 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2385 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2387 s->input_picture[b_frames]->pict_type= I_TYPE;
2391 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2393 && s->input_picture[b_frames]->pict_type== I_TYPE)
2396 s->reordered_input_picture[0]= s->input_picture[b_frames];
2397 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2398 s->reordered_input_picture[0]->pict_type= P_TYPE;
2399 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2400 for(i=0; i<b_frames; i++){
2401 s->reordered_input_picture[i+1]= s->input_picture[i];
2402 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2403 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2408 if(s->reordered_input_picture[0]){
2409 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2411 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2413 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2414 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2416 int i= ff_find_unused_picture(s, 0);
2417 Picture *pic= &s->picture[i];
2419 /* mark us unused / free shared pic */
2421 s->reordered_input_picture[0]->data[i]= NULL;
2422 s->reordered_input_picture[0]->type= 0;
2424 pic->reference = s->reordered_input_picture[0]->reference;
2426 alloc_picture(s, pic, 0);
2428 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2430 s->current_picture_ptr= pic;
2432 // input is not a shared pix -> reuse buffer for current_pix
2434 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2435 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2437 s->current_picture_ptr= s->reordered_input_picture[0];
2439 s->new_picture.data[i]+= INPLACE_OFFSET;
2442 copy_picture(&s->current_picture, s->current_picture_ptr);
2444 s->picture_number= s->new_picture.display_picture_number;
2445 //printf("dpn:%d\n", s->picture_number);
2447 memset(&s->new_picture, 0, sizeof(Picture));
2451 int MPV_encode_picture(AVCodecContext *avctx,
2452 unsigned char *buf, int buf_size, void *data)
2454 MpegEncContext *s = avctx->priv_data;
2455 AVFrame *pic_arg = data;
2456 int i, stuffing_count;
2458 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2459 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2463 for(i=0; i<avctx->thread_count; i++){
2464 int start_y= s->thread_context[i]->start_mb_y;
2465 int end_y= s->thread_context[i]-> end_mb_y;
2466 int h= s->mb_height;
2467 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2468 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2470 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2473 s->picture_in_gop_number++;
2475 if(load_input_picture(s, pic_arg) < 0)
2478 select_input_picture(s);
2481 if(s->new_picture.data[0]){
2482 s->pict_type= s->new_picture.pict_type;
2484 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2485 MPV_frame_start(s, avctx);
2487 encode_picture(s, s->picture_number);
2489 avctx->real_pict_num = s->picture_number;
2490 avctx->header_bits = s->header_bits;
2491 avctx->mv_bits = s->mv_bits;
2492 avctx->misc_bits = s->misc_bits;
2493 avctx->i_tex_bits = s->i_tex_bits;
2494 avctx->p_tex_bits = s->p_tex_bits;
2495 avctx->i_count = s->i_count;
2496 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2497 avctx->skip_count = s->skip_count;
2501 if (s->out_format == FMT_MJPEG)
2502 mjpeg_picture_trailer(s);
2504 if(s->flags&CODEC_FLAG_PASS1)
2505 ff_write_pass1_stats(s);
2508 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2509 avctx->error[i] += s->current_picture_ptr->error[i];
2512 if(s->flags&CODEC_FLAG_PASS1)
2513 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2514 flush_put_bits(&s->pb);
2515 s->frame_bits = put_bits_count(&s->pb);
2517 stuffing_count= ff_vbv_update(s, s->frame_bits);
2519 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2520 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2524 switch(s->codec_id){
2525 case CODEC_ID_MPEG1VIDEO:
2526 case CODEC_ID_MPEG2VIDEO:
2527 while(stuffing_count--){
2528 put_bits(&s->pb, 8, 0);
2531 case CODEC_ID_MPEG4:
2532 put_bits(&s->pb, 16, 0);
2533 put_bits(&s->pb, 16, 0x1C3);
2534 stuffing_count -= 4;
2535 while(stuffing_count--){
2536 put_bits(&s->pb, 8, 0xFF);
2540 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2542 flush_put_bits(&s->pb);
2543 s->frame_bits = put_bits_count(&s->pb);
2546 /* update mpeg1/2 vbv_delay for CBR */
2547 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2548 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2551 assert(s->repeat_first_field==0);
2553 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2554 assert(vbv_delay < 0xFFFF);
2556 s->vbv_delay_ptr[0] &= 0xF8;
2557 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2558 s->vbv_delay_ptr[1] = vbv_delay>>5;
2559 s->vbv_delay_ptr[2] &= 0x07;
2560 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2562 s->total_bits += s->frame_bits;
2563 avctx->frame_bits = s->frame_bits;
2565 assert((pbBufPtr(&s->pb) == s->pb.buf));
2568 assert((s->frame_bits&7)==0);
2570 return s->frame_bits/8;
2573 #endif //CONFIG_ENCODERS
2575 static inline void gmc1_motion(MpegEncContext *s,
2576 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2577 uint8_t **ref_picture)
2580 int offset, src_x, src_y, linesize, uvlinesize;
2581 int motion_x, motion_y;
2584 motion_x= s->sprite_offset[0][0];
2585 motion_y= s->sprite_offset[0][1];
2586 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2587 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2588 motion_x<<=(3-s->sprite_warping_accuracy);
2589 motion_y<<=(3-s->sprite_warping_accuracy);
2590 src_x = clip(src_x, -16, s->width);
2591 if (src_x == s->width)
2593 src_y = clip(src_y, -16, s->height);
2594 if (src_y == s->height)
2597 linesize = s->linesize;
2598 uvlinesize = s->uvlinesize;
2600 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2602 if(s->flags&CODEC_FLAG_EMU_EDGE){
2603 if( (unsigned)src_x >= s->h_edge_pos - 17
2604 || (unsigned)src_y >= s->v_edge_pos - 17){
2605 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2606 ptr= s->edge_emu_buffer;
2610 if((motion_x|motion_y)&7){
2611 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2612 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2616 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2617 if (s->no_rounding){
2618 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2620 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2624 if(s->flags&CODEC_FLAG_GRAY) return;
2626 motion_x= s->sprite_offset[1][0];
2627 motion_y= s->sprite_offset[1][1];
2628 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2629 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2630 motion_x<<=(3-s->sprite_warping_accuracy);
2631 motion_y<<=(3-s->sprite_warping_accuracy);
2632 src_x = clip(src_x, -8, s->width>>1);
2633 if (src_x == s->width>>1)
2635 src_y = clip(src_y, -8, s->height>>1);
2636 if (src_y == s->height>>1)
2639 offset = (src_y * uvlinesize) + src_x;
2640 ptr = ref_picture[1] + offset;
2641 if(s->flags&CODEC_FLAG_EMU_EDGE){
2642 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2643 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2644 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);
2645 ptr= s->edge_emu_buffer;
2649 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2651 ptr = ref_picture[2] + offset;
2653 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);
2654 ptr= s->edge_emu_buffer;
2656 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2661 static inline void gmc_motion(MpegEncContext *s,
2662 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2663 uint8_t **ref_picture)
2666 int linesize, uvlinesize;
2667 const int a= s->sprite_warping_accuracy;
2670 linesize = s->linesize;
2671 uvlinesize = s->uvlinesize;
2673 ptr = ref_picture[0];
2675 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2676 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2678 s->dsp.gmc(dest_y, ptr, linesize, 16,
2681 s->sprite_delta[0][0], s->sprite_delta[0][1],
2682 s->sprite_delta[1][0], s->sprite_delta[1][1],
2683 a+1, (1<<(2*a+1)) - s->no_rounding,
2684 s->h_edge_pos, s->v_edge_pos);
2685 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2686 ox + s->sprite_delta[0][0]*8,
2687 oy + s->sprite_delta[1][0]*8,
2688 s->sprite_delta[0][0], s->sprite_delta[0][1],
2689 s->sprite_delta[1][0], s->sprite_delta[1][1],
2690 a+1, (1<<(2*a+1)) - s->no_rounding,
2691 s->h_edge_pos, s->v_edge_pos);
2693 if(s->flags&CODEC_FLAG_GRAY) return;
2695 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2696 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2698 ptr = ref_picture[1];
2699 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2702 s->sprite_delta[0][0], s->sprite_delta[0][1],
2703 s->sprite_delta[1][0], s->sprite_delta[1][1],
2704 a+1, (1<<(2*a+1)) - s->no_rounding,
2705 s->h_edge_pos>>1, s->v_edge_pos>>1);
2707 ptr = ref_picture[2];
2708 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2711 s->sprite_delta[0][0], s->sprite_delta[0][1],
2712 s->sprite_delta[1][0], s->sprite_delta[1][1],
2713 a+1, (1<<(2*a+1)) - s->no_rounding,
2714 s->h_edge_pos>>1, s->v_edge_pos>>1);
2718 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2719 * @param buf destination buffer
2720 * @param src source buffer
2721 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2722 * @param block_w width of block
2723 * @param block_h height of block
2724 * @param src_x x coordinate of the top left sample of the block in the source buffer
2725 * @param src_y y coordinate of the top left sample of the block in the source buffer
2726 * @param w width of the source buffer
2727 * @param h height of the source buffer
2729 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2730 int src_x, int src_y, int w, int h){
2732 int start_y, start_x, end_y, end_x;
2735 src+= (h-1-src_y)*linesize;
2737 }else if(src_y<=-block_h){
2738 src+= (1-block_h-src_y)*linesize;
2744 }else if(src_x<=-block_w){
2745 src+= (1-block_w-src_x);
2749 start_y= FFMAX(0, -src_y);
2750 start_x= FFMAX(0, -src_x);
2751 end_y= FFMIN(block_h, h-src_y);
2752 end_x= FFMIN(block_w, w-src_x);
2754 // copy existing part
2755 for(y=start_y; y<end_y; y++){
2756 for(x=start_x; x<end_x; x++){
2757 buf[x + y*linesize]= src[x + y*linesize];
2762 for(y=0; y<start_y; y++){
2763 for(x=start_x; x<end_x; x++){
2764 buf[x + y*linesize]= buf[x + start_y*linesize];
2769 for(y=end_y; y<block_h; y++){
2770 for(x=start_x; x<end_x; x++){
2771 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2775 for(y=0; y<block_h; y++){
2777 for(x=0; x<start_x; x++){
2778 buf[x + y*linesize]= buf[start_x + y*linesize];
2782 for(x=end_x; x<block_w; x++){
2783 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2788 static inline int hpel_motion(MpegEncContext *s,
2789 uint8_t *dest, uint8_t *src,
2790 int field_based, int field_select,
2791 int src_x, int src_y,
2792 int width, int height, int stride,
2793 int h_edge_pos, int v_edge_pos,
2794 int w, int h, op_pixels_func *pix_op,
2795 int motion_x, int motion_y)
2800 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2801 src_x += motion_x >> 1;
2802 src_y += motion_y >> 1;
2804 /* WARNING: do no forget half pels */
2805 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2808 src_y = clip(src_y, -16, height);
2809 if (src_y == height)
2811 src += src_y * stride + src_x;
2813 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2814 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2815 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2816 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2817 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2818 src= s->edge_emu_buffer;
2824 pix_op[dxy](dest, src, stride, h);
2828 static inline int hpel_motion_lowres(MpegEncContext *s,
2829 uint8_t *dest, uint8_t *src,
2830 int field_based, int field_select,
2831 int src_x, int src_y,
2832 int width, int height, int stride,
2833 int h_edge_pos, int v_edge_pos,
2834 int w, int h, h264_chroma_mc_func *pix_op,
2835 int motion_x, int motion_y)
2837 const int lowres= s->avctx->lowres;
2838 const int s_mask= (2<<lowres)-1;
2842 if(s->quarter_sample){
2847 sx= motion_x & s_mask;
2848 sy= motion_y & s_mask;
2849 src_x += motion_x >> (lowres+1);
2850 src_y += motion_y >> (lowres+1);
2852 src += src_y * stride + src_x;
2854 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2855 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2856 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2857 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2858 src= s->edge_emu_buffer;
2866 pix_op[lowres](dest, src, stride, h, sx, sy);
2870 /* apply one mpeg motion vector to the three components */
2871 static always_inline void mpeg_motion(MpegEncContext *s,
2872 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2873 int field_based, int bottom_field, int field_select,
2874 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2875 int motion_x, int motion_y, int h)
2877 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2878 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2881 if(s->quarter_sample)
2888 v_edge_pos = s->v_edge_pos >> field_based;
2889 linesize = s->current_picture.linesize[0] << field_based;
2890 uvlinesize = s->current_picture.linesize[1] << field_based;
2892 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2893 src_x = s->mb_x* 16 + (motion_x >> 1);
2894 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2896 if (s->out_format == FMT_H263) {
2897 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2898 mx = (motion_x>>1)|(motion_x&1);
2900 uvdxy = ((my & 1) << 1) | (mx & 1);
2901 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2902 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2904 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2908 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2912 uvsrc_x = s->mb_x*8 + mx;
2913 uvsrc_y = s->mb_y*8 + my;
2915 if(s->chroma_y_shift){
2918 uvdxy = ((my & 1) << 1) | (mx & 1);
2919 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2920 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2922 if(s->chroma_x_shift){
2925 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2926 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2937 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2938 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2939 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2941 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2942 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2943 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2944 s->codec_id == CODEC_ID_MPEG1VIDEO){
2945 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2948 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2949 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2950 ptr_y = s->edge_emu_buffer;
2951 if(!(s->flags&CODEC_FLAG_GRAY)){
2952 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2953 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2954 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2955 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2956 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2962 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2963 dest_y += s->linesize;
2964 dest_cb+= s->uvlinesize;
2965 dest_cr+= s->uvlinesize;
2969 ptr_y += s->linesize;
2970 ptr_cb+= s->uvlinesize;
2971 ptr_cr+= s->uvlinesize;
2974 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2976 if(!(s->flags&CODEC_FLAG_GRAY)){
2977 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2978 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2980 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2981 if(s->out_format == FMT_H261){
2982 ff_h261_loop_filter(s);
2987 /* apply one mpeg motion vector to the three components */
2988 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2989 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2990 int field_based, int bottom_field, int field_select,
2991 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2992 int motion_x, int motion_y, int h)
2994 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2995 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2996 const int lowres= s->avctx->lowres;
2997 const int block_s= 8>>lowres;
2998 const int s_mask= (2<<lowres)-1;
2999 const int h_edge_pos = s->h_edge_pos >> lowres;
3000 const int v_edge_pos = s->v_edge_pos >> lowres;
3001 linesize = s->current_picture.linesize[0] << field_based;
3002 uvlinesize = s->current_picture.linesize[1] << field_based;
3004 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3010 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3013 sx= motion_x & s_mask;
3014 sy= motion_y & s_mask;
3015 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3016 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3018 if (s->out_format == FMT_H263) {
3019 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3020 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3023 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3026 uvsx = (2*mx) & s_mask;
3027 uvsy = (2*my) & s_mask;
3028 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3029 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3035 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3036 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3039 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3040 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3041 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3043 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3044 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3045 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3046 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3047 ptr_y = s->edge_emu_buffer;
3048 if(!(s->flags&CODEC_FLAG_GRAY)){
3049 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3050 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3051 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3052 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3053 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3059 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3060 dest_y += s->linesize;
3061 dest_cb+= s->uvlinesize;
3062 dest_cr+= s->uvlinesize;
3066 ptr_y += s->linesize;
3067 ptr_cb+= s->uvlinesize;
3068 ptr_cr+= s->uvlinesize;
3073 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3075 if(!(s->flags&CODEC_FLAG_GRAY)){
3076 uvsx <<= 2 - lowres;
3077 uvsy <<= 2 - lowres;
3078 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3079 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3081 //FIXME h261 lowres loop filter
3084 //FIXME move to dsputil, avg variant, 16x16 version
3085 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3087 uint8_t * const top = src[1];
3088 uint8_t * const left = src[2];
3089 uint8_t * const mid = src[0];
3090 uint8_t * const right = src[3];
3091 uint8_t * const bottom= src[4];
3092 #define OBMC_FILTER(x, t, l, m, r, b)\
3093 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3094 #define OBMC_FILTER4(x, t, l, m, r, b)\
3095 OBMC_FILTER(x , t, l, m, r, b);\
3096 OBMC_FILTER(x+1 , t, l, m, r, b);\
3097 OBMC_FILTER(x +stride, t, l, m, r, b);\
3098 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3101 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3102 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3103 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3104 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3105 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3106 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3108 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3109 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3110 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3111 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3113 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3114 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3115 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3116 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3118 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3119 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3120 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3121 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3123 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3124 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3125 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3126 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3127 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3128 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3130 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3131 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3132 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3133 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3136 /* obmc for 1 8x8 luma block */
3137 static inline void obmc_motion(MpegEncContext *s,
3138 uint8_t *dest, uint8_t *src,
3139 int src_x, int src_y,
3140 op_pixels_func *pix_op,
3141 int16_t mv[5][2]/* mid top left right bottom*/)
3147 assert(s->quarter_sample==0);
3150 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3153 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3154 hpel_motion(s, ptr[i], src, 0, 0,
3156 s->width, s->height, s->linesize,
3157 s->h_edge_pos, s->v_edge_pos,
3159 mv[i][0], mv[i][1]);
3163 put_obmc(dest, ptr, s->linesize);
3166 static inline void qpel_motion(MpegEncContext *s,
3167 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3168 int field_based, int bottom_field, int field_select,
3169 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3170 qpel_mc_func (*qpix_op)[16],
3171 int motion_x, int motion_y, int h)
3173 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3174 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3176 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3177 src_x = s->mb_x * 16 + (motion_x >> 2);
3178 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3180 v_edge_pos = s->v_edge_pos >> field_based;
3181 linesize = s->linesize << field_based;
3182 uvlinesize = s->uvlinesize << field_based;
3187 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3188 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3189 mx= (motion_x>>1) + rtab[motion_x&7];
3190 my= (motion_y>>1) + rtab[motion_y&7];
3191 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3192 mx= (motion_x>>1)|(motion_x&1);
3193 my= (motion_y>>1)|(motion_y&1);
3201 uvdxy= (mx&1) | ((my&1)<<1);
3205 uvsrc_x = s->mb_x * 8 + mx;
3206 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3208 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3209 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3210 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3212 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3213 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3214 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3215 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3216 ptr_y= s->edge_emu_buffer;
3217 if(!(s->flags&CODEC_FLAG_GRAY)){
3218 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3219 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3220 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3221 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3222 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3229 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3232 dest_y += s->linesize;
3233 dest_cb+= s->uvlinesize;
3234 dest_cr+= s->uvlinesize;
3238 ptr_y += s->linesize;
3239 ptr_cb += s->uvlinesize;
3240 ptr_cr += s->uvlinesize;
3242 //damn interlaced mode
3243 //FIXME boundary mirroring is not exactly correct here
3244 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3245 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3247 if(!(s->flags&CODEC_FLAG_GRAY)){
3248 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3249 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3253 inline int ff_h263_round_chroma(int x){
3255 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3258 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3263 * h263 chorma 4mv motion compensation.
3265 static inline void chroma_4mv_motion(MpegEncContext *s,
3266 uint8_t *dest_cb, uint8_t *dest_cr,
3267 uint8_t **ref_picture,
3268 op_pixels_func *pix_op,
3270 int dxy, emu=0, src_x, src_y, offset;
3273 /* In case of 8X8, we construct a single chroma motion vector
3274 with a special rounding */
3275 mx= ff_h263_round_chroma(mx);
3276 my= ff_h263_round_chroma(my);
3278 dxy = ((my & 1) << 1) | (mx & 1);
3282 src_x = s->mb_x * 8 + mx;
3283 src_y = s->mb_y * 8 + my;
3284 src_x = clip(src_x, -8, s->width/2);
3285 if (src_x == s->width/2)
3287 src_y = clip(src_y, -8, s->height/2);
3288 if (src_y == s->height/2)
3291 offset = (src_y * (s->uvlinesize)) + src_x;
3292 ptr = ref_picture[1] + offset;
3293 if(s->flags&CODEC_FLAG_EMU_EDGE){
3294 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3295 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3296 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3297 ptr= s->edge_emu_buffer;
3301 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3303 ptr = ref_picture[2] + offset;
3305 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3306 ptr= s->edge_emu_buffer;
3308 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3311 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3312 uint8_t *dest_cb, uint8_t *dest_cr,
3313 uint8_t **ref_picture,
3314 h264_chroma_mc_func *pix_op,
3316 const int lowres= s->avctx->lowres;
3317 const int block_s= 8>>lowres;
3318 const int s_mask= (2<<lowres)-1;
3319 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3320 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3321 int emu=0, src_x, src_y, offset, sx, sy;
3324 if(s->quarter_sample){
3329 /* In case of 8X8, we construct a single chroma motion vector
3330 with a special rounding */
3331 mx= ff_h263_round_chroma(mx);
3332 my= ff_h263_round_chroma(my);
3336 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3337 src_y = s->mb_y*block_s + (my >> (lowres+1));
3339 offset = src_y * s->uvlinesize + src_x;
3340 ptr = ref_picture[1] + offset;
3341 if(s->flags&CODEC_FLAG_EMU_EDGE){
3342 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3343 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3344 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3345 ptr= s->edge_emu_buffer;
3351 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3353 ptr = ref_picture[2] + offset;
3355 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3356 ptr= s->edge_emu_buffer;
3358 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3362 * motion compensation of a single macroblock
3364 * @param dest_y luma destination pointer
3365 * @param dest_cb chroma cb/u destination pointer
3366 * @param dest_cr chroma cr/v destination pointer
3367 * @param dir direction (0->forward, 1->backward)
3368 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3369 * @param pic_op halfpel motion compensation function (average or put normally)
3370 * @param pic_op qpel motion compensation function (average or put normally)
3371 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3373 static inline void MPV_motion(MpegEncContext *s,
3374 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3375 int dir, uint8_t **ref_picture,
3376 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3378 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3380 uint8_t *ptr, *dest;
3385 if(s->obmc && s->pict_type != B_TYPE){
3386 int16_t mv_cache[4][4][2];
3387 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3388 const int mot_stride= s->b8_stride;
3389 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3391 assert(!s->mb_skipped);
3393 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3394 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3395 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3397 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3398 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3400 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3403 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3404 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3405 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3407 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3408 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3411 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3412 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3413 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3415 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3416 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3422 const int x= (i&1)+1;
3423 const int y= (i>>1)+1;
3425 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3426 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3427 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3428 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3429 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3431 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3433 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3440 if(!(s->flags&CODEC_FLAG_GRAY))
3441 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3446 switch(s->mv_type) {
3449 if(s->real_sprite_warping_points==1){
3450 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3453 gmc_motion(s, dest_y, dest_cb, dest_cr,
3456 }else if(s->quarter_sample){
3457 qpel_motion(s, dest_y, dest_cb, dest_cr,
3459 ref_picture, pix_op, qpix_op,
3460 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3462 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3463 ref_picture, pix_op,
3464 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3467 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3469 ref_picture, pix_op,
3470 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3476 if(s->quarter_sample){
3478 motion_x = s->mv[dir][i][0];
3479 motion_y = s->mv[dir][i][1];
3481 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3482 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3483 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3485 /* WARNING: do no forget half pels */
3486 src_x = clip(src_x, -16, s->width);
3487 if (src_x == s->width)
3489 src_y = clip(src_y, -16, s->height);
3490 if (src_y == s->height)
3493 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3494 if(s->flags&CODEC_FLAG_EMU_EDGE){
3495 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3496 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3497 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
3498 ptr= s->edge_emu_buffer;
3501 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3502 qpix_op[1][dxy](dest, ptr, s->linesize);
3504 mx += s->mv[dir][i][0]/2;
3505 my += s->mv[dir][i][1]/2;
3509 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3510 ref_picture[0], 0, 0,
3511 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3512 s->width, s->height, s->linesize,
3513 s->h_edge_pos, s->v_edge_pos,
3515 s->mv[dir][i][0], s->mv[dir][i][1]);
3517 mx += s->mv[dir][i][0];
3518 my += s->mv[dir][i][1];
3522 if(!(s->flags&CODEC_FLAG_GRAY))
3523 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3526 if (s->picture_structure == PICT_FRAME) {
3527 if(s->quarter_sample){
3529 qpel_motion(s, dest_y, dest_cb, dest_cr,
3530 1, i, s->field_select[dir][i],
3531 ref_picture, pix_op, qpix_op,
3532 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3536 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3537 1, 0, s->field_select[dir][0],
3538 ref_picture, pix_op,
3539 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3541 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3542 1, 1, s->field_select[dir][1],
3543 ref_picture, pix_op,
3544 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3547 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3548 ref_picture= s->current_picture_ptr->data;
3551 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3552 0, 0, s->field_select[dir][0],
3553 ref_picture, pix_op,
3554 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3559 uint8_t ** ref2picture;
3561 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3562 ref2picture= ref_picture;
3564 ref2picture= s->current_picture_ptr->data;
3567 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3568 0, 0, s->field_select[dir][i],
3569 ref2picture, pix_op,
3570 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3572 dest_y += 16*s->linesize;
3573 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3574 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3578 if(s->picture_structure == PICT_FRAME){
3582 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3584 ref_picture, pix_op,
3585 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3587 pix_op = s->dsp.avg_pixels_tab;
3591 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3592 0, 0, s->picture_structure != i+1,
3593 ref_picture, pix_op,
3594 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3596 // after put we make avg of the same block
3597 pix_op=s->dsp.avg_pixels_tab;
3599 //opposite parity is always in the same frame if this is second field
3600 if(!s->first_field){
3601 ref_picture = s->current_picture_ptr->data;
3611 * motion compensation of a single macroblock
3613 * @param dest_y luma destination pointer
3614 * @param dest_cb chroma cb/u destination pointer
3615 * @param dest_cr chroma cr/v destination pointer
3616 * @param dir direction (0->forward, 1->backward)
3617 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3618 * @param pic_op halfpel motion compensation function (average or put normally)
3619 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3621 static inline void MPV_motion_lowres(MpegEncContext *s,
3622 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3623 int dir, uint8_t **ref_picture,
3624 h264_chroma_mc_func *pix_op)
3628 const int lowres= s->avctx->lowres;
3629 const int block_s= 8>>lowres;
3634 switch(s->mv_type) {
3636 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3638 ref_picture, pix_op,
3639 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3645 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3646 ref_picture[0], 0, 0,
3647 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3648 s->width, s->height, s->linesize,
3649 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3650 block_s, block_s, pix_op,
3651 s->mv[dir][i][0], s->mv[dir][i][1]);
3653 mx += s->mv[dir][i][0];
3654 my += s->mv[dir][i][1];
3657 if(!(s->flags&CODEC_FLAG_GRAY))
3658 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3661 if (s->picture_structure == PICT_FRAME) {
3663 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3664 1, 0, s->field_select[dir][0],
3665 ref_picture, pix_op,
3666 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3668 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3669 1, 1, s->field_select[dir][1],
3670 ref_picture, pix_op,
3671 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3673 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3674 ref_picture= s->current_picture_ptr->data;
3677 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3678 0, 0, s->field_select[dir][0],
3679 ref_picture, pix_op,
3680 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3685 uint8_t ** ref2picture;
3687 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3688 ref2picture= ref_picture;
3690 ref2picture= s->current_picture_ptr->data;
3693 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3694 0, 0, s->field_select[dir][i],
3695 ref2picture, pix_op,
3696 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3698 dest_y += 2*block_s*s->linesize;
3699 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3700 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3704 if(s->picture_structure == PICT_FRAME){
3708 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3710 ref_picture, pix_op,
3711 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3713 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3717 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3718 0, 0, s->picture_structure != i+1,
3719 ref_picture, pix_op,
3720 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3722 // after put we make avg of the same block
3723 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3725 //opposite parity is always in the same frame if this is second field
3726 if(!s->first_field){
3727 ref_picture = s->current_picture_ptr->data;
3736 /* put block[] to dest[] */
3737 static inline void put_dct(MpegEncContext *s,
3738 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3740 s->dct_unquantize_intra(s, block, i, qscale);
3741 s->dsp.idct_put (dest, line_size, block);
3744 /* add block[] to dest[] */
3745 static inline void add_dct(MpegEncContext *s,
3746 DCTELEM *block, int i, uint8_t *dest, int line_size)
3748 if (s->block_last_index[i] >= 0) {
3749 s->dsp.idct_add (dest, line_size, block);
3753 static inline void add_dequant_dct(MpegEncContext *s,
3754 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3756 if (s->block_last_index[i] >= 0) {
3757 s->dct_unquantize_inter(s, block, i, qscale);
3759 s->dsp.idct_add (dest, line_size, block);
3764 * cleans dc, ac, coded_block for the current non intra MB
3766 void ff_clean_intra_table_entries(MpegEncContext *s)
3768 int wrap = s->b8_stride;
3769 int xy = s->block_index[0];
3772 s->dc_val[0][xy + 1 ] =
3773 s->dc_val[0][xy + wrap] =
3774 s->dc_val[0][xy + 1 + wrap] = 1024;
3776 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3777 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3778 if (s->msmpeg4_version>=3) {
3779 s->coded_block[xy ] =
3780 s->coded_block[xy + 1 ] =
3781 s->coded_block[xy + wrap] =
3782 s->coded_block[xy + 1 + wrap] = 0;
3785 wrap = s->mb_stride;
3786 xy = s->mb_x + s->mb_y * wrap;
3788 s->dc_val[2][xy] = 1024;
3790 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3791 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3793 s->mbintra_table[xy]= 0;
3796 /* generic function called after a macroblock has been parsed by the
3797 decoder or after it has been encoded by the encoder.
3799 Important variables used:
3800 s->mb_intra : true if intra macroblock
3801 s->mv_dir : motion vector direction
3802 s->mv_type : motion vector type
3803 s->mv : motion vector
3804 s->interlaced_dct : true if interlaced dct used (mpeg2)
3806 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3809 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3811 if(s->avctx->xvmc_acceleration){
3812 XVMC_decode_mb(s);//xvmc uses pblocks
3820 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3821 /* save DCT coefficients */
3823 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3826 *dct++ = block[i][s->dsp.idct_permutation[j]];
3829 s->current_picture.qscale_table[mb_xy]= s->qscale;
3831 /* update DC predictors for P macroblocks */
3833 if (s->h263_pred || s->h263_aic) {
3834 if(s->mbintra_table[mb_xy])
3835 ff_clean_intra_table_entries(s);
3839 s->last_dc[2] = 128 << s->intra_dc_precision;
3842 else if (s->h263_pred || s->h263_aic)
3843 s->mbintra_table[mb_xy]=1;
3845 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3846 uint8_t *dest_y, *dest_cb, *dest_cr;
3847 int dct_linesize, dct_offset;
3848 op_pixels_func (*op_pix)[4];
3849 qpel_mc_func (*op_qpix)[16];
3850 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3851 const int uvlinesize= s->current_picture.linesize[1];
3852 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3853 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3855 /* avoid copy if macroblock skipped in last frame too */
3856 /* skip only during decoding as we might trash the buffers during encoding a bit */
3858 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3859 const int age= s->current_picture.age;
3863 if (s->mb_skipped) {
3865 assert(s->pict_type!=I_TYPE);
3867 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3868 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3870 /* if previous was skipped too, then nothing to do ! */
3871 if (*mbskip_ptr >= age && s->current_picture.reference){
3874 } else if(!s->current_picture.reference){
3875 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3876 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3878 *mbskip_ptr = 0; /* not skipped */
3882 dct_linesize = linesize << s->interlaced_dct;
3883 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3887 dest_cb= s->dest[1];
3888 dest_cr= s->dest[2];
3890 dest_y = s->b_scratchpad;
3891 dest_cb= s->b_scratchpad+16*linesize;
3892 dest_cr= s->b_scratchpad+32*linesize;
3896 /* motion handling */
3897 /* decoding or more than one mb_type (MC was already done otherwise) */
3900 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3902 if (s->mv_dir & MV_DIR_FORWARD) {
3903 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3904 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3906 if (s->mv_dir & MV_DIR_BACKWARD) {
3907 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3910 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3911 op_pix = s->dsp.put_pixels_tab;
3912 op_qpix= s->dsp.put_qpel_pixels_tab;
3914 op_pix = s->dsp.put_no_rnd_pixels_tab;
3915 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3917 if (s->mv_dir & MV_DIR_FORWARD) {
3918 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3919 op_pix = s->dsp.avg_pixels_tab;
3920 op_qpix= s->dsp.avg_qpel_pixels_tab;
3922 if (s->mv_dir & MV_DIR_BACKWARD) {
3923 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3928 /* skip dequant / idct if we are really late ;) */
3929 if(s->hurry_up>1) goto skip_idct;
3930 if(s->avctx->skip_idct){
3931 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3932 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3933 || s->avctx->skip_idct >= AVDISCARD_ALL)
3937 /* add dct residue */
3938 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3939 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3940 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3941 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3942 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3943 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3945 if(!(s->flags&CODEC_FLAG_GRAY)){
3946 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3947 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3949 } else if(s->codec_id != CODEC_ID_WMV2){
3950 add_dct(s, block[0], 0, dest_y , dct_linesize);
3951 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3952 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3953 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3955 if(!(s->flags&CODEC_FLAG_GRAY)){
3956 if(s->chroma_y_shift){//Chroma420
3957 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3958 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3961 dct_linesize = uvlinesize << s->interlaced_dct;
3962 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3964 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3965 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3966 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3967 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3968 if(!s->chroma_x_shift){//Chroma444
3969 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3970 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3971 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3972 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3978 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3981 /* dct only in intra block */
3982 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3983 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3984 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3985 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3986 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3988 if(!(s->flags&CODEC_FLAG_GRAY)){
3989 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3990 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3993 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
3994 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
3995 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
3996 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3998 if(!(s->flags&CODEC_FLAG_GRAY)){
3999 if(s->chroma_y_shift){
4000 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4001 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4004 dct_linesize = uvlinesize << s->interlaced_dct;
4005 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4007 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4008 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4009 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4010 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4011 if(!s->chroma_x_shift){//Chroma444
4012 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4013 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4014 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4015 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4023 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4024 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4025 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4030 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4031 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4032 else MPV_decode_mb_internal(s, block, 0);
4035 #ifdef CONFIG_ENCODERS
4037 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4039 static const char tab[64]=
4051 DCTELEM *block= s->block[n];
4052 const int last_index= s->block_last_index[n];
4057 threshold= -threshold;
4061 /* are all which we could set to zero are allready zero? */
4062 if(last_index<=skip_dc - 1) return;
4064 for(i=0; i<=last_index; i++){
4065 const int j = s->intra_scantable.permutated[i];
4066 const int level = ABS(block[j]);
4068 if(skip_dc && i==0) continue;
4077 if(score >= threshold) return;
4078 for(i=skip_dc; i<=last_index; i++){
4079 const int j = s->intra_scantable.permutated[i];
4082 if(block[0]) s->block_last_index[n]= 0;
4083 else s->block_last_index[n]= -1;
4086 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4089 const int maxlevel= s->max_qcoeff;
4090 const int minlevel= s->min_qcoeff;
4094 i=1; //skip clipping of intra dc
4098 for(;i<=last_index; i++){
4099 const int j= s->intra_scantable.permutated[i];
4100 int level = block[j];
4102 if (level>maxlevel){
4105 }else if(level<minlevel){
4113 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4114 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4117 #endif //CONFIG_ENCODERS
4121 * @param h is the normal height, this will be reduced automatically if needed for the last row
4123 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4124 if (s->avctx->draw_horiz_band) {
4128 if(s->picture_structure != PICT_FRAME){
4131 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4134 h= FFMIN(h, s->avctx->height - y);
4136 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4137 src= (AVFrame*)s->current_picture_ptr;
4138 else if(s->last_picture_ptr)
4139 src= (AVFrame*)s->last_picture_ptr;
4143 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4149 offset[0]= y * s->linesize;;
4151 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4157 s->avctx->draw_horiz_band(s->avctx, src, offset,
4158 y, s->picture_structure, h);
4162 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4163 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4164 const int uvlinesize= s->current_picture.linesize[1];
4165 const int mb_size= 4 - s->avctx->lowres;
4167 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4168 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4169 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4170 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4171 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4172 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4173 //block_index is not used by mpeg2, so it is not affected by chroma_format
4175 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4176 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4177 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4179 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4181 s->dest[0] += s->mb_y * linesize << mb_size;
4182 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4183 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4187 #ifdef CONFIG_ENCODERS
4189 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4199 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4200 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4201 int v= ptr[x2 + y2*stride];
4207 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4212 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4214 int16_t weight[6][64];
4215 DCTELEM orig[6][64];
4216 const int mb_x= s->mb_x;
4217 const int mb_y= s->mb_y;
4220 int dct_offset = s->linesize*8; //default for progressive frames
4221 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4224 for(i=0; i<6; i++) skip_dct[i]=0;
4226 if(s->adaptive_quant){
4227 const int last_qp= s->qscale;
4228 const int mb_xy= mb_x + mb_y*s->mb_stride;
4230 s->lambda= s->lambda_table[mb_xy];
4233 if(!(s->flags&CODEC_FLAG_QP_RD)){
4234 s->dquant= s->qscale - last_qp;
4236 if(s->out_format==FMT_H263){
4237 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4239 if(s->codec_id==CODEC_ID_MPEG4){
4241 if(s->pict_type == B_TYPE){
4243 s->dquant= (s->dquant/2)*2;
4244 if(s->mv_dir&MV_DIRECT)
4247 if(s->mv_type==MV_TYPE_8X8)
4253 ff_set_qscale(s, last_qp + s->dquant);
4254 }else if(s->flags&CODEC_FLAG_QP_RD)
4255 ff_set_qscale(s, s->qscale + s->dquant);
4257 wrap_y = s->linesize;
4258 wrap_c = s->uvlinesize;
4259 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4260 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4261 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4263 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4264 uint8_t *ebuf= s->edge_emu_buffer + 32;
4265 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
4267 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4268 ptr_cb= ebuf+18*wrap_y;
4269 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4270 ptr_cr= ebuf+18*wrap_y+8;
4274 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4275 int progressive_score, interlaced_score;
4277 s->interlaced_dct=0;
4278 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4279 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4281 if(progressive_score > 0){
4282 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4283 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4284 if(progressive_score > interlaced_score){
4285 s->interlaced_dct=1;
4293 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4294 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4295 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4296 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4298 if(s->flags&CODEC_FLAG_GRAY){
4302 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4303 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4306 op_pixels_func (*op_pix)[4];
4307 qpel_mc_func (*op_qpix)[16];
4308 uint8_t *dest_y, *dest_cb, *dest_cr;
4310 dest_y = s->dest[0];
4311 dest_cb = s->dest[1];
4312 dest_cr = s->dest[2];
4314 if ((!s->no_rounding) || s->pict_type==B_TYPE){
4315 op_pix = s->dsp.put_pixels_tab;
4316 op_qpix= s->dsp.put_qpel_pixels_tab;
4318 op_pix = s->dsp.put_no_rnd_pixels_tab;
4319 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4322 if (s->mv_dir & MV_DIR_FORWARD) {
4323 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4324 op_pix = s->dsp.avg_pixels_tab;
4325 op_qpix= s->dsp.avg_qpel_pixels_tab;
4327 if (s->mv_dir & MV_DIR_BACKWARD) {
4328 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4331 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4332 int progressive_score, interlaced_score;
4334 s->interlaced_dct=0;
4335 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4336 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4338 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4340 if(progressive_score>0){
4341 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4342 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4344 if(progressive_score > interlaced_score){
4345 s->interlaced_dct=1;
4353 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4354 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4355 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4356 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4358 if(s->flags&CODEC_FLAG_GRAY){
4362 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4363 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4365 /* pre quantization */
4366 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4368 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4369 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4370 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4371 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
4372 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4373 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4377 if(s->avctx->quantizer_noise_shaping){
4378 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4379 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4380 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4381 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4382 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4383 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4384 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4387 /* DCT & quantize */
4388 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4393 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4394 // FIXME we could decide to change to quantizer instead of clipping
4395 // JS: I don't think that would be a good idea it could lower quality instead
4396 // of improve it. Just INTRADC clipping deserves changes in quantizer
4397 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4399 s->block_last_index[i]= -1;
4401 if(s->avctx->quantizer_noise_shaping){
4404 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4409 if(s->luma_elim_threshold && !s->mb_intra)
4411 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4412 if(s->chroma_elim_threshold && !s->mb_intra)
4414 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4416 if(s->flags & CODEC_FLAG_CBP_RD){
4418 if(s->block_last_index[i] == -1)
4419 s->coded_score[i]= INT_MAX/256;
4424 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4425 s->block_last_index[4]=
4426 s->block_last_index[5]= 0;
4428 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4431 //non c quantize code returns incorrect block_last_index FIXME
4432 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4435 if(s->block_last_index[i]>0){
4436 for(j=63; j>0; j--){
4437 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4439 s->block_last_index[i]= j;
4444 /* huffman encode */
4445 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4446 case CODEC_ID_MPEG1VIDEO:
4447 case CODEC_ID_MPEG2VIDEO:
4448 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4449 case CODEC_ID_MPEG4:
4450 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4451 case CODEC_ID_MSMPEG4V2:
4452 case CODEC_ID_MSMPEG4V3:
4454 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4456 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4457 #ifdef CONFIG_H261_ENCODER
4459 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4462 case CODEC_ID_H263P:
4466 h263_encode_mb(s, s->block, motion_x, motion_y); break;
4467 case CODEC_ID_MJPEG:
4468 mjpeg_encode_mb(s, s->block); break;
4474 #endif //CONFIG_ENCODERS
4476 void ff_mpeg_flush(AVCodecContext *avctx){
4478 MpegEncContext *s = avctx->priv_data;
4480 if(s==NULL || s->picture==NULL)
4483 for(i=0; i<MAX_PICTURE_COUNT; i++){
4484 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4485 || s->picture[i].type == FF_BUFFER_TYPE_USER))
4486 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4488 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4490 s->mb_x= s->mb_y= 0;
4492 s->parse_context.state= -1;
4493 s->parse_context.frame_start_found= 0;
4494 s->parse_context.overread= 0;
4495 s->parse_context.overread_index= 0;
4496 s->parse_context.index= 0;
4497 s->parse_context.last_index= 0;
4498 s->bitstream_buffer_size=0;
4501 #ifdef CONFIG_ENCODERS
4502 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4504 const uint16_t *srcw= (uint16_t*)src;
4505 int words= length>>4;
4506 int bits= length&15;
4509 if(length==0) return;
4512 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4513 }else if(put_bits_count(pb)&7){
4514 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4516 for(i=0; put_bits_count(pb)&31; i++)
4517 put_bits(pb, 8, src[i]);
4519 memcpy(pbBufPtr(pb), src+i, 2*words-i);
4520 skip_put_bytes(pb, 2*words-i);
4523 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4526 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4529 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4532 d->mb_skip_run= s->mb_skip_run;
4534 d->last_dc[i]= s->last_dc[i];
4537 d->mv_bits= s->mv_bits;
4538 d->i_tex_bits= s->i_tex_bits;
4539 d->p_tex_bits= s->p_tex_bits;
4540 d->i_count= s->i_count;
4541 d->f_count= s->f_count;
4542 d->b_count= s->b_count;
4543 d->skip_count= s->skip_count;
4544 d->misc_bits= s->misc_bits;
4548 d->qscale= s->qscale;
4549 d->dquant= s->dquant;
4552 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4555 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4556 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4559 d->mb_skip_run= s->mb_skip_run;
4561 d->last_dc[i]= s->last_dc[i];
4564 d->mv_bits= s->mv_bits;
4565 d->i_tex_bits= s->i_tex_bits;
4566 d->p_tex_bits= s->p_tex_bits;
4567 d->i_count= s->i_count;
4568 d->f_count= s->f_count;
4569 d->b_count= s->b_count;
4570 d->skip_count= s->skip_count;
4571 d->misc_bits= s->misc_bits;
4573 d->mb_intra= s->mb_intra;
4574 d->mb_skipped= s->mb_skipped;
4575 d->mv_type= s->mv_type;
4576 d->mv_dir= s->mv_dir;
4578 if(s->data_partitioning){
4580 d->tex_pb= s->tex_pb;
4584 d->block_last_index[i]= s->block_last_index[i];
4585 d->interlaced_dct= s->interlaced_dct;
4586 d->qscale= s->qscale;
4589 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4590 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4591 int *dmin, int *next_block, int motion_x, int motion_y)
4594 uint8_t *dest_backup[3];
4596 copy_context_before_encode(s, backup, type);
4598 s->block= s->blocks[*next_block];
4599 s->pb= pb[*next_block];
4600 if(s->data_partitioning){
4601 s->pb2 = pb2 [*next_block];
4602 s->tex_pb= tex_pb[*next_block];
4606 memcpy(dest_backup, s->dest, sizeof(s->dest));
4607 s->dest[0] = s->rd_scratchpad;
4608 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4609 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4610 assert(s->linesize >= 32); //FIXME
4613 encode_mb(s, motion_x, motion_y);
4615 score= put_bits_count(&s->pb);
4616 if(s->data_partitioning){
4617 score+= put_bits_count(&s->pb2);
4618 score+= put_bits_count(&s->tex_pb);
4621 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4622 MPV_decode_mb(s, s->block);
4624 score *= s->lambda2;
4625 score += sse_mb(s) << FF_LAMBDA_SHIFT;
4629 memcpy(s->dest, dest_backup, sizeof(s->dest));
4636 copy_context_after_encode(best, s, type);
4640 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4641 uint32_t *sq = squareTbl + 256;
4646 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4647 else if(w==8 && h==8)
4648 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4652 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4661 static int sse_mb(MpegEncContext *s){
4665 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4666 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4669 if(s->avctx->mb_cmp == FF_CMP_NSSE){
4670 return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4671 +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4672 +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4674 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4675 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4676 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4679 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
4680 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
4681 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
4684 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4685 MpegEncContext *s= arg;
4689 s->me.dia_size= s->avctx->pre_dia_size;
4690 s->first_slice_line=1;
4691 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4692 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4693 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4695 s->first_slice_line=0;
4703 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4704 MpegEncContext *s= arg;
4706 s->me.dia_size= s->avctx->dia_size;
4707 s->first_slice_line=1;
4708 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4709 s->mb_x=0; //for block init below
4710 ff_init_block_index(s);
4711 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4712 s->block_index[0]+=2;
4713 s->block_index[1]+=2;
4714 s->block_index[2]+=2;
4715 s->block_index[3]+=2;
4717 /* compute motion vector & mb_type and store in context */
4718 if(s->pict_type==B_TYPE)
4719 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4721 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4723 s->first_slice_line=0;
4728 static int mb_var_thread(AVCodecContext *c, void *arg){
4729 MpegEncContext *s= arg;
4732 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4733 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4736 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4738 int sum = s->dsp.pix_sum(pix, s->linesize);
4740 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4742 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4743 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4744 s->me.mb_var_sum_temp += varc;
4750 static void write_slice_end(MpegEncContext *s){
4751 if(s->codec_id==CODEC_ID_MPEG4){
4752 if(s->partitioned_frame){
4753 ff_mpeg4_merge_partitions(s);
4756 ff_mpeg4_stuffing(&s->pb);
4757 }else if(s->out_format == FMT_MJPEG){
4758 ff_mjpeg_stuffing(&s->pb);
4761 align_put_bits(&s->pb);
4762 flush_put_bits(&s->pb);
4764 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4765 s->misc_bits+= get_bits_diff(s);
4768 static int encode_thread(AVCodecContext *c, void *arg){
4769 MpegEncContext *s= arg;
4770 int mb_x, mb_y, pdif = 0;
4772 MpegEncContext best_s, backup_s;
4773 uint8_t bit_buf[2][MAX_MB_BYTES];
4774 uint8_t bit_buf2[2][MAX_MB_BYTES];
4775 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4776 PutBitContext pb[2], pb2[2], tex_pb[2];
4777 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4780 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4781 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4782 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4785 s->last_bits= put_bits_count(&s->pb);
4796 /* init last dc values */
4797 /* note: quant matrix value (8) is implied here */
4798 s->last_dc[i] = 128 << s->intra_dc_precision;
4800 s->current_picture.error[i] = 0;
4803 memset(s->last_mv, 0, sizeof(s->last_mv));
4807 switch(s->codec_id){
4809 case CODEC_ID_H263P:
4811 s->gob_index = ff_h263_get_gob_height(s);
4813 case CODEC_ID_MPEG4:
4814 if(s->partitioned_frame)
4815 ff_mpeg4_init_partitions(s);
4821 s->first_slice_line = 1;
4822 s->ptr_lastgob = s->pb.buf;
4823 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4824 // printf("row %d at %X\n", s->mb_y, (int)s);
4828 ff_set_qscale(s, s->qscale);
4829 ff_init_block_index(s);
4831 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4832 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4833 int mb_type= s->mb_type[xy];
4838 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4839 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4842 if(s->data_partitioning){
4843 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4844 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4845 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4851 s->mb_y = mb_y; // moved into loop, can get changed by H.261
4852 ff_update_block_index(s);
4854 #ifdef CONFIG_H261_ENCODER
4855 if(s->codec_id == CODEC_ID_H261){
4856 ff_h261_reorder_mb_index(s);
4857 xy= s->mb_y*s->mb_stride + s->mb_x;
4858 mb_type= s->mb_type[xy];
4862 /* write gob / video packet header */
4864 int current_packet_size, is_gob_start;
4866 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4868 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4870 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4872 switch(s->codec_id){
4874 case CODEC_ID_H263P:
4875 if(!s->h263_slice_structured)
4876 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4878 case CODEC_ID_MPEG2VIDEO:
4879 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4880 case CODEC_ID_MPEG1VIDEO:
4881 if(s->mb_skip_run) is_gob_start=0;
4886 if(s->start_mb_y != mb_y || mb_x!=0){
4889 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4890 ff_mpeg4_init_partitions(s);
4894 assert((put_bits_count(&s->pb)&7) == 0);
4895 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4897 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4898 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4899 int d= 100 / s->avctx->error_rate;
4901 current_packet_size=0;
4902 #ifndef ALT_BITSTREAM_WRITER
4903 s->pb.buf_ptr= s->ptr_lastgob;
4905 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4909 if (s->avctx->rtp_callback){
4910 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
4911 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
4914 switch(s->codec_id){
4915 case CODEC_ID_MPEG4:
4916 ff_mpeg4_encode_video_packet_header(s);
4917 ff_mpeg4_clean_buffers(s);
4919 case CODEC_ID_MPEG1VIDEO:
4920 case CODEC_ID_MPEG2VIDEO:
4921 ff_mpeg1_encode_slice_header(s);
4922 ff_mpeg1_clean_buffers(s);
4925 case CODEC_ID_H263P:
4926 h263_encode_gob_header(s, mb_y);
4930 if(s->flags&CODEC_FLAG_PASS1){
4931 int bits= put_bits_count(&s->pb);
4932 s->misc_bits+= bits - s->last_bits;
4936 s->ptr_lastgob += current_packet_size;
4937 s->first_slice_line=1;
4938 s->resync_mb_x=mb_x;
4939 s->resync_mb_y=mb_y;
4943 if( (s->resync_mb_x == s->mb_x)
4944 && s->resync_mb_y+1 == s->mb_y){
4945 s->first_slice_line=0;
4949 s->dquant=0; //only for QP_RD
4951 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4953 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4955 copy_context_before_encode(&backup_s, s, -1);
4957 best_s.data_partitioning= s->data_partitioning;
4958 best_s.partitioned_frame= s->partitioned_frame;
4959 if(s->data_partitioning){
4960 backup_s.pb2= s->pb2;
4961 backup_s.tex_pb= s->tex_pb;
4964 if(mb_type&CANDIDATE_MB_TYPE_INTER){
4965 s->mv_dir = MV_DIR_FORWARD;
4966 s->mv_type = MV_TYPE_16X16;
4968 s->mv[0][0][0] = s->p_mv_table[xy][0];
4969 s->mv[0][0][1] = s->p_mv_table[xy][1];
4970 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
4971 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4973 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
4974 s->mv_dir = MV_DIR_FORWARD;
4975 s->mv_type = MV_TYPE_FIELD;
4978 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4979 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4980 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4982 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
4983 &dmin, &next_block, 0, 0);
4985 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
4986 s->mv_dir = MV_DIR_FORWARD;
4987 s->mv_type = MV_TYPE_16X16;
4991 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
4992 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4994 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
4995 s->mv_dir = MV_DIR_FORWARD;
4996 s->mv_type = MV_TYPE_8X8;
4999 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5000 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5002 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5003 &dmin, &next_block, 0, 0);
5005 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5006 s->mv_dir = MV_DIR_FORWARD;
5007 s->mv_type = MV_TYPE_16X16;
5009 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5010 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5011 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5012 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5014 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5015 s->mv_dir = MV_DIR_BACKWARD;
5016 s->mv_type = MV_TYPE_16X16;
5018 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5019 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5020 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5021 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5023 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5024 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5025 s->mv_type = MV_TYPE_16X16;
5027 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5028 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5029 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5030 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5031 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5032 &dmin, &next_block, 0, 0);
5034 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5035 int mx= s->b_direct_mv_table[xy][0];
5036 int my= s->b_direct_mv_table[xy][1];
5038 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5040 ff_mpeg4_set_direct_mv(s, mx, my);
5041 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5042 &dmin, &next_block, mx, my);
5044 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5045 s->mv_dir = MV_DIR_FORWARD;
5046 s->mv_type = MV_TYPE_FIELD;
5049 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5050 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5051 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5053 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5054 &dmin, &next_block, 0, 0);
5056 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5057 s->mv_dir = MV_DIR_BACKWARD;
5058 s->mv_type = MV_TYPE_FIELD;
5061 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5062 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5063 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5065 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5066 &dmin, &next_block, 0, 0);
5068 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5069 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5070 s->mv_type = MV_TYPE_FIELD;
5072 for(dir=0; dir<2; dir++){
5074 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5075 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5076 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5079 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5080 &dmin, &next_block, 0, 0);
5082 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5084 s->mv_type = MV_TYPE_16X16;
5088 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5089 &dmin, &next_block, 0, 0);
5090 if(s->h263_pred || s->h263_aic){
5092 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5094 ff_clean_intra_table_entries(s); //old mode?
5098 if(s->flags & CODEC_FLAG_QP_RD){
5099 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
5100 const int last_qp= backup_s.qscale;
5101 int dquant, dir, qp, dc[6];
5103 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5105 assert(backup_s.dquant == 0);
5108 s->mv_dir= best_s.mv_dir;
5109 s->mv_type = MV_TYPE_16X16;
5110 s->mb_intra= best_s.mb_intra;
5111 s->mv[0][0][0] = best_s.mv[0][0][0];
5112 s->mv[0][0][1] = best_s.mv[0][0][1];
5113 s->mv[1][0][0] = best_s.mv[1][0][0];
5114 s->mv[1][0][1] = best_s.mv[1][0][1];
5116 dir= s->pict_type == B_TYPE ? 2 : 1;
5117 if(last_qp + dir > s->avctx->qmax) dir= -dir;
5118 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
5119 qp= last_qp + dquant;
5120 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5122 backup_s.dquant= dquant;
5123 if(s->mb_intra && s->dc_val[0]){
5125 dc[i]= s->dc_val[0][ s->block_index[i] ];
5126 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5130 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5131 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5132 if(best_s.qscale != qp){
5133 if(s->mb_intra && s->dc_val[0]){
5135 s->dc_val[0][ s->block_index[i] ]= dc[i];
5136 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5139 if(dir > 0 && dquant==dir){
5147 s->current_picture.qscale_table[xy]= qp;
5151 copy_context_after_encode(s, &best_s, -1);
5153 pb_bits_count= put_bits_count(&s->pb);
5154 flush_put_bits(&s->pb);
5155 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5158 if(s->data_partitioning){
5159 pb2_bits_count= put_bits_count(&s->pb2);
5160 flush_put_bits(&s->pb2);
5161 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5162 s->pb2= backup_s.pb2;
5164 tex_pb_bits_count= put_bits_count(&s->tex_pb);
5165 flush_put_bits(&s->tex_pb);
5166 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5167 s->tex_pb= backup_s.tex_pb;
5169 s->last_bits= put_bits_count(&s->pb);
5171 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5172 ff_h263_update_motion_val(s);
5174 if(next_block==0){ //FIXME 16 vs linesize16
5175 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5176 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5177 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5180 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5181 MPV_decode_mb(s, s->block);
5183 int motion_x, motion_y;
5184 s->mv_type=MV_TYPE_16X16;
5185 // only one MB-Type possible
5188 case CANDIDATE_MB_TYPE_INTRA:
5191 motion_x= s->mv[0][0][0] = 0;
5192 motion_y= s->mv[0][0][1] = 0;
5194 case CANDIDATE_MB_TYPE_INTER:
5195 s->mv_dir = MV_DIR_FORWARD;
5197 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5198 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5200 case CANDIDATE_MB_TYPE_INTER_I:
5201 s->mv_dir = MV_DIR_FORWARD;
5202 s->mv_type = MV_TYPE_FIELD;
5205 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5206 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5207 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5209 motion_x = motion_y = 0;
5211 case CANDIDATE_MB_TYPE_INTER4V:
5212 s->mv_dir = MV_DIR_FORWARD;
5213 s->mv_type = MV_TYPE_8X8;
5216 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5217 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5219 motion_x= motion_y= 0;
5221 case CANDIDATE_MB_TYPE_DIRECT:
5222 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5224 motion_x=s->b_direct_mv_table[xy][0];
5225 motion_y=s->b_direct_mv_table[xy][1];
5226 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5228 case CANDIDATE_MB_TYPE_BIDIR:
5229 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5233 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5234 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5235 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5236 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5238 case CANDIDATE_MB_TYPE_BACKWARD:
5239 s->mv_dir = MV_DIR_BACKWARD;
5241 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5242 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5244 case CANDIDATE_MB_TYPE_FORWARD:
5245 s->mv_dir = MV_DIR_FORWARD;
5247 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5248 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5249 // printf(" %d %d ", motion_x, motion_y);
5251 case CANDIDATE_MB_TYPE_FORWARD_I:
5252 s->mv_dir = MV_DIR_FORWARD;
5253 s->mv_type = MV_TYPE_FIELD;
5256 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5257 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5258 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5260 motion_x=motion_y=0;
5262 case CANDIDATE_MB_TYPE_BACKWARD_I:
5263 s->mv_dir = MV_DIR_BACKWARD;
5264 s->mv_type = MV_TYPE_FIELD;
5267 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5268 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5269 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5271 motion_x=motion_y=0;
5273 case CANDIDATE_MB_TYPE_BIDIR_I:
5274 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5275 s->mv_type = MV_TYPE_FIELD;
5277 for(dir=0; dir<2; dir++){
5279 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5280 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5281 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5284 motion_x=motion_y=0;
5287 motion_x=motion_y=0; //gcc warning fix
5288 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5291 encode_mb(s, motion_x, motion_y);
5293 // RAL: Update last macroblock type
5294 s->last_mv_dir = s->mv_dir;
5296 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5297 ff_h263_update_motion_val(s);
5299 MPV_decode_mb(s, s->block);
5302 /* clean the MV table in IPS frames for direct mode in B frames */
5303 if(s->mb_intra /* && I,P,S_TYPE */){
5304 s->p_mv_table[xy][0]=0;
5305 s->p_mv_table[xy][1]=0;
5308 if(s->flags&CODEC_FLAG_PSNR){
5312 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
5313 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
5315 s->current_picture.error[0] += sse(
5316 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
5317 s->dest[0], w, h, s->linesize);
5318 s->current_picture.error[1] += sse(
5319 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5320 s->dest[1], w>>1, h>>1, s->uvlinesize);
5321 s->current_picture.error[2] += sse(
5322 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5323 s->dest[2], w>>1, h>>1, s->uvlinesize);
5326 if(s->out_format == FMT_H263)
5327 ff_h263_loop_filter(s);
5329 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5333 //not beautiful here but we must write it before flushing so it has to be here
5334 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5335 msmpeg4_encode_ext_header(s);
5339 /* Send the last GOB if RTP */
5340 if (s->avctx->rtp_callback) {
5341 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5342 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5343 /* Call the RTP callback to send the last GOB */
5345 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5351 #define MERGE(field) dst->field += src->field; src->field=0
5352 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5353 MERGE(me.scene_change_score);
5354 MERGE(me.mc_mb_var_sum_temp);
5355 MERGE(me.mb_var_sum_temp);
5358 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
5361 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5362 MERGE(dct_count[1]);
5372 MERGE(padding_bug_score);
5373 MERGE(current_picture.error[0]);
5374 MERGE(current_picture.error[1]);
5375 MERGE(current_picture.error[2]);
5377 if(dst->avctx->noise_reduction){
5378 for(i=0; i<64; i++){
5379 MERGE(dct_error_sum[0][i]);
5380 MERGE(dct_error_sum[1][i]);
5384 assert(put_bits_count(&src->pb) % 8 ==0);
5385 assert(put_bits_count(&dst->pb) % 8 ==0);
5386 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5387 flush_put_bits(&dst->pb);
5390 static void estimate_qp(MpegEncContext *s, int dry_run){
5391 if (!s->fixed_qscale)
5392 s->current_picture_ptr->quality=
5393 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5395 if(s->adaptive_quant){
5396 switch(s->codec_id){
5397 case CODEC_ID_MPEG4:
5398 ff_clean_mpeg4_qscales(s);
5401 case CODEC_ID_H263P:
5403 ff_clean_h263_qscales(s);
5407 s->lambda= s->lambda_table[0];
5410 s->lambda= s->current_picture.quality;
5411 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5415 static void encode_picture(MpegEncContext *s, int picture_number)
5420 s->picture_number = picture_number;
5422 /* Reset the average MB variance */
5423 s->me.mb_var_sum_temp =
5424 s->me.mc_mb_var_sum_temp = 0;
5426 /* we need to initialize some time vars before we can encode b-frames */
5427 // RAL: Condition added for MPEG1VIDEO
5428 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5429 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5431 s->me.scene_change_score=0;
5433 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5435 if(s->pict_type==I_TYPE){
5436 if(s->msmpeg4_version >= 3) s->no_rounding=1;
5437 else s->no_rounding=0;
5438 }else if(s->pict_type!=B_TYPE){
5439 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5440 s->no_rounding ^= 1;
5443 if(s->flags & CODEC_FLAG_PASS2){
5445 ff_get_2pass_fcode(s);
5446 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5447 if(s->pict_type==B_TYPE)
5448 s->lambda= s->last_lambda_for[s->pict_type];
5450 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5454 s->mb_intra=0; //for the rate distortion & bit compare functions
5455 for(i=1; i<s->avctx->thread_count; i++){
5456 ff_update_duplicate_context(s->thread_context[i], s);
5461 /* Estimate motion for every MB */
5462 if(s->pict_type != I_TYPE){
5463 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5464 s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5465 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5466 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
5467 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5471 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5472 }else /* if(s->pict_type == I_TYPE) */{
5474 for(i=0; i<s->mb_stride*s->mb_height; i++)
5475 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5477 if(!s->fixed_qscale){
5478 /* finding spatial complexity for I-frame rate control */
5479 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5482 for(i=1; i<s->avctx->thread_count; i++){
5483 merge_context_after_me(s, s->thread_context[i]);
5485 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5486 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5489 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5490 s->pict_type= I_TYPE;
5491 for(i=0; i<s->mb_stride*s->mb_height; i++)
5492 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5493 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5497 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5498 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5500 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5502 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5503 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5504 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5507 ff_fix_long_p_mvs(s);
5508 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5509 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5513 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5514 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5519 if(s->pict_type==B_TYPE){
5522 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5523 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5524 s->f_code = FFMAX(a, b);
5526 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5527 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5528 s->b_code = FFMAX(a, b);
5530 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5531 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5532 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5533 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5534 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5536 for(dir=0; dir<2; dir++){
5539 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5540 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5541 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5542 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5552 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5553 s->qscale= 3; //reduce clipping problems
5555 if (s->out_format == FMT_MJPEG) {
5556 /* for mjpeg, we do include qscale in the matrix */
5557 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5559 int j= s->dsp.idct_permutation[i];
5561 s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3) & 0xFF;
5563 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5564 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5568 //FIXME var duplication
5569 s->current_picture_ptr->key_frame=
5570 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5571 s->current_picture_ptr->pict_type=
5572 s->current_picture.pict_type= s->pict_type;
5574 if(s->current_picture.key_frame)
5575 s->picture_in_gop_number=0;
5577 s->last_bits= put_bits_count(&s->pb);
5578 switch(s->out_format) {
5580 mjpeg_picture_header(s);
5582 #ifdef CONFIG_H261_ENCODER
5584 ff_h261_encode_picture_header(s, picture_number);
5588 if (s->codec_id == CODEC_ID_WMV2)
5589 ff_wmv2_encode_picture_header(s, picture_number);
5590 else if (s->h263_msmpeg4)
5591 msmpeg4_encode_picture_header(s, picture_number);
5592 else if (s->h263_pred)
5593 mpeg4_encode_picture_header(s, picture_number);
5594 #ifdef CONFIG_RV10_ENCODER
5595 else if (s->codec_id == CODEC_ID_RV10)
5596 rv10_encode_picture_header(s, picture_number);
5598 #ifdef CONFIG_RV20_ENCODER
5599 else if (s->codec_id == CODEC_ID_RV20)
5600 rv20_encode_picture_header(s, picture_number);
5602 else if (s->codec_id == CODEC_ID_FLV1)
5603 ff_flv_encode_picture_header(s, picture_number);
5605 h263_encode_picture_header(s, picture_number);
5608 mpeg1_encode_picture_header(s, picture_number);
5615 bits= put_bits_count(&s->pb);
5616 s->header_bits= bits - s->last_bits;
5618 for(i=1; i<s->avctx->thread_count; i++){
5619 update_duplicate_context_after_me(s->thread_context[i], s);
5621 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5622 for(i=1; i<s->avctx->thread_count; i++){
5623 merge_context_after_encode(s, s->thread_context[i]);
5628 #endif //CONFIG_ENCODERS
5630 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5631 const int intra= s->mb_intra;
5634 s->dct_count[intra]++;
5636 for(i=0; i<64; i++){
5637 int level= block[i];
5641 s->dct_error_sum[intra][i] += level;
5642 level -= s->dct_offset[intra][i];
5643 if(level<0) level=0;
5645 s->dct_error_sum[intra][i] -= level;
5646 level += s->dct_offset[intra][i];
5647 if(level>0) level=0;
5654 #ifdef CONFIG_ENCODERS
5656 static int dct_quantize_trellis_c(MpegEncContext *s,
5657 DCTELEM *block, int n,
5658 int qscale, int *overflow){
5660 const uint8_t *scantable= s->intra_scantable.scantable;
5661 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5663 unsigned int threshold1, threshold2;
5675 int coeff_count[64];
5676 int qmul, qadd, start_i, last_non_zero, i, dc;
5677 const int esc_length= s->ac_esc_length;
5679 uint8_t * last_length;
5680 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5682 s->dsp.fdct (block);
5684 if(s->dct_error_sum)
5685 s->denoise_dct(s, block);
5687 qadd= ((qscale-1)|1)*8;
5698 /* For AIC we skip quant/dequant of INTRADC */
5703 /* note: block[0] is assumed to be positive */
5704 block[0] = (block[0] + (q >> 1)) / q;
5707 qmat = s->q_intra_matrix[qscale];
5708 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5709 bias= 1<<(QMAT_SHIFT-1);
5710 length = s->intra_ac_vlc_length;
5711 last_length= s->intra_ac_vlc_last_length;
5715 qmat = s->q_inter_matrix[qscale];
5716 length = s->inter_ac_vlc_length;
5717 last_length= s->inter_ac_vlc_last_length;
5721 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5722 threshold2= (threshold1<<1);
5724 for(i=63; i>=start_i; i--) {
5725 const int j = scantable[i];
5726 int level = block[j] * qmat[j];
5728 if(((unsigned)(level+threshold1))>threshold2){
5734 for(i=start_i; i<=last_non_zero; i++) {
5735 const int j = scantable[i];
5736 int level = block[j] * qmat[j];
5738 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
5739 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
5740 if(((unsigned)(level+threshold1))>threshold2){
5742 level= (bias + level)>>QMAT_SHIFT;
5744 coeff[1][i]= level-1;
5745 // coeff[2][k]= level-2;
5747 level= (bias - level)>>QMAT_SHIFT;
5748 coeff[0][i]= -level;
5749 coeff[1][i]= -level+1;
5750 // coeff[2][k]= -level+2;
5752 coeff_count[i]= FFMIN(level, 2);
5753 assert(coeff_count[i]);
5756 coeff[0][i]= (level>>31)|1;
5761 *overflow= s->max_qcoeff < max; //overflow might have happened
5763 if(last_non_zero < start_i){
5764 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5765 return last_non_zero;
5768 score_tab[start_i]= 0;
5769 survivor[0]= start_i;
5772 for(i=start_i; i<=last_non_zero; i++){
5774 const int dct_coeff= ABS(block[ scantable[i] ]);
5775 const int zero_distoration= dct_coeff*dct_coeff;
5776 int best_score=256*256*256*120;
5777 for(level_index=0; level_index < coeff_count[i]; level_index++){
5779 int level= coeff[level_index][i];
5780 const int alevel= ABS(level);
5785 if(s->out_format == FMT_H263){
5786 unquant_coeff= alevel*qmul + qadd;
5788 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5790 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5791 unquant_coeff = (unquant_coeff - 1) | 1;
5793 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5794 unquant_coeff = (unquant_coeff - 1) | 1;
5799 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5801 if((level&(~127)) == 0){
5802 for(j=survivor_count-1; j>=0; j--){
5803 int run= i - survivor[j];
5804 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5805 score += score_tab[i-run];
5807 if(score < best_score){
5810 level_tab[i+1]= level-64;
5814 if(s->out_format == FMT_H263){
5815 for(j=survivor_count-1; j>=0; j--){
5816 int run= i - survivor[j];
5817 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5818 score += score_tab[i-run];
5819 if(score < last_score){
5822 last_level= level-64;
5828 distoration += esc_length*lambda;
5829 for(j=survivor_count-1; j>=0; j--){
5830 int run= i - survivor[j];
5831 int score= distoration + score_tab[i-run];
5833 if(score < best_score){
5836 level_tab[i+1]= level-64;
5840 if(s->out_format == FMT_H263){
5841 for(j=survivor_count-1; j>=0; j--){
5842 int run= i - survivor[j];
5843 int score= distoration + score_tab[i-run];
5844 if(score < last_score){
5847 last_level= level-64;
5855 score_tab[i+1]= best_score;
5857 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5858 if(last_non_zero <= 27){
5859 for(; survivor_count; survivor_count--){
5860 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5864 for(; survivor_count; survivor_count--){
5865 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5870 survivor[ survivor_count++ ]= i+1;
5873 if(s->out_format != FMT_H263){
5874 last_score= 256*256*256*120;
5875 for(i= survivor[0]; i<=last_non_zero + 1; i++){
5876 int score= score_tab[i];
5877 if(i) score += lambda*2; //FIXME exacter?
5879 if(score < last_score){
5882 last_level= level_tab[i];
5883 last_run= run_tab[i];
5888 s->coded_score[n] = last_score;
5891 last_non_zero= last_i - 1;
5892 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5894 if(last_non_zero < start_i)
5895 return last_non_zero;
5897 if(last_non_zero == 0 && start_i == 0){
5899 int best_score= dc * dc;
5901 for(i=0; i<coeff_count[0]; i++){
5902 int level= coeff[i][0];
5903 int alevel= ABS(level);
5904 int unquant_coeff, score, distortion;
5906 if(s->out_format == FMT_H263){
5907 unquant_coeff= (alevel*qmul + qadd)>>3;
5909 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5910 unquant_coeff = (unquant_coeff - 1) | 1;
5912 unquant_coeff = (unquant_coeff + 4) >> 3;
5913 unquant_coeff<<= 3 + 3;
5915 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5917 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
5918 else score= distortion + esc_length*lambda;
5920 if(score < best_score){
5922 best_level= level - 64;
5925 block[0]= best_level;
5926 s->coded_score[n] = best_score - dc*dc;
5927 if(best_level == 0) return -1;
5928 else return last_non_zero;
5934 block[ perm_scantable[last_non_zero] ]= last_level;
5937 for(; i>start_i; i -= run_tab[i] + 1){
5938 block[ perm_scantable[i-1] ]= level_tab[i];
5941 return last_non_zero;
5944 //#define REFINE_STATS 1
5945 static int16_t basis[64][64];
5947 static void build_basis(uint8_t *perm){
5954 double s= 0.25*(1<<BASIS_SHIFT);
5956 int perm_index= perm[index];
5957 if(i==0) s*= sqrt(0.5);
5958 if(j==0) s*= sqrt(0.5);
5959 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
5966 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
5967 DCTELEM *block, int16_t *weight, DCTELEM *orig,
5970 DECLARE_ALIGNED_16(DCTELEM, d1[64]);
5972 const uint8_t *scantable= s->intra_scantable.scantable;
5973 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5974 // unsigned int threshold1, threshold2;
5979 int qmul, qadd, start_i, last_non_zero, i, dc;
5981 uint8_t * last_length;
5983 int rle_index, run, q, sum;
5986 static int after_last=0;
5987 static int to_zero=0;
5988 static int from_zero=0;
5991 static int messed_sign=0;
5994 if(basis[0][0] == 0)
5995 build_basis(s->dsp.idct_permutation);
6006 /* For AIC we skip quant/dequant of INTRADC */
6010 q <<= RECON_SHIFT-3;
6011 /* note: block[0] is assumed to be positive */
6013 // block[0] = (block[0] + (q >> 1)) / q;
6015 qmat = s->q_intra_matrix[qscale];
6016 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
6017 // bias= 1<<(QMAT_SHIFT-1);
6018 length = s->intra_ac_vlc_length;
6019 last_length= s->intra_ac_vlc_last_length;
6023 qmat = s->q_inter_matrix[qscale];
6024 length = s->inter_ac_vlc_length;
6025 last_length= s->inter_ac_vlc_last_length;
6027 last_non_zero = s->block_last_index[n];
6032 dc += (1<<(RECON_SHIFT-1));
6033 for(i=0; i<64; i++){
6034 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6037 STOP_TIMER("memset rem[]")}
6040 for(i=0; i<64; i++){
6045 w= ABS(weight[i]) + qns*one;
6046 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
6049 // w=weight[i] = (63*qns + (w/2)) / w;
6055 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6061 for(i=start_i; i<=last_non_zero; i++){
6062 int j= perm_scantable[i];
6063 const int level= block[j];
6067 if(level<0) coeff= qmul*level - qadd;
6068 else coeff= qmul*level + qadd;
6069 run_tab[rle_index++]=run;
6072 s->dsp.add_8x8basis(rem, basis[j], coeff);
6078 if(last_non_zero>0){
6079 STOP_TIMER("init rem[]")
6086 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6089 int run2, best_unquant_change=0, analyze_gradient;
6093 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
6095 if(analyze_gradient){
6099 for(i=0; i<64; i++){
6102 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6105 STOP_TIMER("rem*w*w")}
6115 const int level= block[0];
6116 int change, old_coeff;
6118 assert(s->mb_intra);
6122 for(change=-1; change<=1; change+=2){
6123 int new_level= level + change;
6124 int score, new_coeff;
6126 new_coeff= q*new_level;
6127 if(new_coeff >= 2048 || new_coeff < 0)
6130 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6131 if(score<best_score){
6134 best_change= change;
6135 best_unquant_change= new_coeff - old_coeff;
6142 run2= run_tab[rle_index++];
6146 for(i=start_i; i<64; i++){
6147 int j= perm_scantable[i];
6148 const int level= block[j];
6149 int change, old_coeff;
6151 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6155 if(level<0) old_coeff= qmul*level - qadd;
6156 else old_coeff= qmul*level + qadd;
6157 run2= run_tab[rle_index++]; //FIXME ! maybe after last
6161 assert(run2>=0 || i >= last_non_zero );
6164 for(change=-1; change<=1; change+=2){
6165 int new_level= level + change;
6166 int score, new_coeff, unquant_change;
6169 if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
6173 if(new_level<0) new_coeff= qmul*new_level - qadd;
6174 else new_coeff= qmul*new_level + qadd;
6175 if(new_coeff >= 2048 || new_coeff <= -2048)
6177 //FIXME check for overflow
6180 if(level < 63 && level > -63){
6181 if(i < last_non_zero)
6182 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6183 - length[UNI_AC_ENC_INDEX(run, level+64)];
6185 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6186 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
6189 assert(ABS(new_level)==1);
6191 if(analyze_gradient){
6192 int g= d1[ scantable[i] ];
6193 if(g && (g^new_level) >= 0)
6197 if(i < last_non_zero){
6198 int next_i= i + run2 + 1;
6199 int next_level= block[ perm_scantable[next_i] ] + 64;
6201 if(next_level&(~127))
6204 if(next_i < last_non_zero)
6205 score += length[UNI_AC_ENC_INDEX(run, 65)]
6206 + length[UNI_AC_ENC_INDEX(run2, next_level)]
6207 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6209 score += length[UNI_AC_ENC_INDEX(run, 65)]
6210 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6211 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6213 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6215 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6216 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6222 assert(ABS(level)==1);
6224 if(i < last_non_zero){
6225 int next_i= i + run2 + 1;
6226 int next_level= block[ perm_scantable[next_i] ] + 64;
6228 if(next_level&(~127))
6231 if(next_i < last_non_zero)
6232 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6233 - length[UNI_AC_ENC_INDEX(run2, next_level)]
6234 - length[UNI_AC_ENC_INDEX(run, 65)];
6236 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6237 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6238 - length[UNI_AC_ENC_INDEX(run, 65)];
6240 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6242 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6243 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6250 unquant_change= new_coeff - old_coeff;
6251 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6253 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6254 if(score<best_score){
6257 best_change= change;
6258 best_unquant_change= unquant_change;
6262 prev_level= level + 64;
6263 if(prev_level&(~127))
6272 STOP_TIMER("iterative step")}
6276 int j= perm_scantable[ best_coeff ];
6278 block[j] += best_change;
6280 if(best_coeff > last_non_zero){
6281 last_non_zero= best_coeff;
6289 if(block[j] - best_change){
6290 if(ABS(block[j]) > ABS(block[j] - best_change)){
6302 for(; last_non_zero>=start_i; last_non_zero--){
6303 if(block[perm_scantable[last_non_zero]])
6309 if(256*256*256*64 % count == 0){
6310 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
6315 for(i=start_i; i<=last_non_zero; i++){
6316 int j= perm_scantable[i];
6317 const int level= block[j];
6320 run_tab[rle_index++]=run;
6327 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6333 if(last_non_zero>0){
6334 STOP_TIMER("iterative search")
6339 return last_non_zero;
6342 static int dct_quantize_c(MpegEncContext *s,
6343 DCTELEM *block, int n,
6344 int qscale, int *overflow)
6346 int i, j, level, last_non_zero, q, start_i;
6348 const uint8_t *scantable= s->intra_scantable.scantable;
6351 unsigned int threshold1, threshold2;
6353 s->dsp.fdct (block);
6355 if(s->dct_error_sum)
6356 s->denoise_dct(s, block);
6366 /* For AIC we skip quant/dequant of INTRADC */
6369 /* note: block[0] is assumed to be positive */
6370 block[0] = (block[0] + (q >> 1)) / q;
6373 qmat = s->q_intra_matrix[qscale];
6374 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6378 qmat = s->q_inter_matrix[qscale];
6379 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6381 threshold1= (1<<QMAT_SHIFT) - bias - 1;
6382 threshold2= (threshold1<<1);
6383 for(i=63;i>=start_i;i--) {
6385 level = block[j] * qmat[j];
6387 if(((unsigned)(level+threshold1))>threshold2){
6394 for(i=start_i; i<=last_non_zero; i++) {
6396 level = block[j] * qmat[j];
6398 // if( bias+level >= (1<<QMAT_SHIFT)
6399 // || bias-level >= (1<<QMAT_SHIFT)){
6400 if(((unsigned)(level+threshold1))>threshold2){
6402 level= (bias + level)>>QMAT_SHIFT;
6405 level= (bias - level)>>QMAT_SHIFT;
6413 *overflow= s->max_qcoeff < max; //overflow might have happened
6415 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6416 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6417 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6419 return last_non_zero;
6422 #endif //CONFIG_ENCODERS
6424 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6425 DCTELEM *block, int n, int qscale)
6427 int i, level, nCoeffs;
6428 const uint16_t *quant_matrix;
6430 nCoeffs= s->block_last_index[n];
6433 block[0] = block[0] * s->y_dc_scale;
6435 block[0] = block[0] * s->c_dc_scale;
6436 /* XXX: only mpeg1 */
6437 quant_matrix = s->intra_matrix;
6438 for(i=1;i<=nCoeffs;i++) {
6439 int j= s->intra_scantable.permutated[i];
6444 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6445 level = (level - 1) | 1;
6448 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6449 level = (level - 1) | 1;
6456 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6457 DCTELEM *block, int n, int qscale)
6459 int i, level, nCoeffs;
6460 const uint16_t *quant_matrix;
6462 nCoeffs= s->block_last_index[n];
6464 quant_matrix = s->inter_matrix;
6465 for(i=0; i<=nCoeffs; i++) {
6466 int j= s->intra_scantable.permutated[i];
6471 level = (((level << 1) + 1) * qscale *
6472 ((int) (quant_matrix[j]))) >> 4;
6473 level = (level - 1) | 1;
6476 level = (((level << 1) + 1) * qscale *
6477 ((int) (quant_matrix[j]))) >> 4;
6478 level = (level - 1) | 1;
6485 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6486 DCTELEM *block, int n, int qscale)
6488 int i, level, nCoeffs;
6489 const uint16_t *quant_matrix;
6491 if(s->alternate_scan) nCoeffs= 63;
6492 else nCoeffs= s->block_last_index[n];
6495 block[0] = block[0] * s->y_dc_scale;
6497 block[0] = block[0] * s->c_dc_scale;
6498 quant_matrix = s->intra_matrix;
6499 for(i=1;i<=nCoeffs;i++) {
6500 int j= s->intra_scantable.permutated[i];
6505 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6508 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6515 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6516 DCTELEM *block, int n, int qscale)
6518 int i, level, nCoeffs;
6519 const uint16_t *quant_matrix;
6522 if(s->alternate_scan) nCoeffs= 63;
6523 else nCoeffs= s->block_last_index[n];
6525 quant_matrix = s->inter_matrix;
6526 for(i=0; i<=nCoeffs; i++) {
6527 int j= s->intra_scantable.permutated[i];
6532 level = (((level << 1) + 1) * qscale *
6533 ((int) (quant_matrix[j]))) >> 4;
6536 level = (((level << 1) + 1) * qscale *
6537 ((int) (quant_matrix[j]))) >> 4;
6546 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6547 DCTELEM *block, int n, int qscale)
6549 int i, level, qmul, qadd;
6552 assert(s->block_last_index[n]>=0);
6558 block[0] = block[0] * s->y_dc_scale;
6560 block[0] = block[0] * s->c_dc_scale;
6561 qadd = (qscale - 1) | 1;
6568 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6570 for(i=1; i<=nCoeffs; i++) {
6574 level = level * qmul - qadd;
6576 level = level * qmul + qadd;
6583 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6584 DCTELEM *block, int n, int qscale)
6586 int i, level, qmul, qadd;
6589 assert(s->block_last_index[n]>=0);
6591 qadd = (qscale - 1) | 1;
6594 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6596 for(i=0; i<=nCoeffs; i++) {
6600 level = level * qmul - qadd;
6602 level = level * qmul + qadd;
6609 #ifdef CONFIG_ENCODERS
6610 AVCodec h263_encoder = {
6614 sizeof(MpegEncContext),
6618 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6621 AVCodec h263p_encoder = {
6625 sizeof(MpegEncContext),
6629 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6632 AVCodec flv_encoder = {
6636 sizeof(MpegEncContext),
6640 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6643 AVCodec rv10_encoder = {
6647 sizeof(MpegEncContext),
6651 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6654 AVCodec rv20_encoder = {
6658 sizeof(MpegEncContext),
6662 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6665 AVCodec mpeg4_encoder = {
6669 sizeof(MpegEncContext),
6673 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6674 .capabilities= CODEC_CAP_DELAY,
6677 AVCodec msmpeg4v1_encoder = {
6681 sizeof(MpegEncContext),
6685 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6688 AVCodec msmpeg4v2_encoder = {
6692 sizeof(MpegEncContext),
6696 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6699 AVCodec msmpeg4v3_encoder = {
6703 sizeof(MpegEncContext),
6707 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6710 AVCodec wmv1_encoder = {
6714 sizeof(MpegEncContext),
6718 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6721 AVCodec mjpeg_encoder = {
6725 sizeof(MpegEncContext),
6729 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, -1},
6732 #endif //CONFIG_ENCODERS