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 file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
37 #include "libvo/fastmemcpy.h"
43 #ifdef CONFIG_ENCODERS
44 static int encode_picture(MpegEncContext *s, int picture_number);
45 #endif //CONFIG_ENCODERS
46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
59 DCTELEM *block, int n, int qscale);
60 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
61 #ifdef CONFIG_ENCODERS
62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
65 static int sse_mb(MpegEncContext *s);
66 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
67 #endif //CONFIG_ENCODERS
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
71 extern void XVMC_field_end(MpegEncContext *s);
72 extern void XVMC_decode_mb(MpegEncContext *s);
75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
78 /* enable all paranoid tests for rounding, overflows, etc... */
84 /* for jpeg fast DCT */
87 static const uint16_t aanscales[64] = {
88 /* precomputed values scaled up by 14 bits */
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
99 static const uint8_t h263_chroma_roundtab[16] = {
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
104 static const uint8_t ff_default_chroma_qscale_table[32]={
105 // 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
106 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
109 #ifdef CONFIG_ENCODERS
110 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
111 static uint8_t default_fcode_tab[MAX_MV*2+1];
113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
115 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
121 for(qscale=qmin; qscale<=qmax; qscale++){
123 if (dsp->fdct == ff_jpeg_fdct_islow
124 #ifdef FAAN_POSTSCALE
125 || dsp->fdct == ff_faandct
129 const int j= dsp->idct_permutation[i];
130 /* 16 <= qscale * quant_matrix[i] <= 7905 */
131 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
132 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
133 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
135 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
136 (qscale * quant_matrix[j]));
138 } else if (dsp->fdct == fdct_ifast
139 #ifndef FAAN_POSTSCALE
140 || dsp->fdct == ff_faandct
144 const int j= dsp->idct_permutation[i];
145 /* 16 <= qscale * quant_matrix[i] <= 7905 */
146 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
147 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
148 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
150 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
151 (aanscales[i] * qscale * quant_matrix[j]));
155 const int j= dsp->idct_permutation[i];
156 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
157 So 16 <= qscale * quant_matrix[i] <= 7905
158 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
159 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
161 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
162 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
163 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
165 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
166 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
170 for(i=intra; i<64; i++){
172 if (dsp->fdct == fdct_ifast
173 #ifndef FAAN_POSTSCALE
174 || dsp->fdct == ff_faandct
177 max= (8191LL*aanscales[i]) >> 14;
179 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
185 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
189 static inline void update_qscale(MpegEncContext *s){
190 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
191 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
193 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
195 #endif //CONFIG_ENCODERS
197 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
201 st->scantable= src_scantable;
205 j = src_scantable[i];
206 st->permutated[i] = permutation[j];
215 j = st->permutated[i];
217 st->raster_end[i]= end;
221 #ifdef CONFIG_ENCODERS
222 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
228 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
233 #endif //CONFIG_ENCODERS
235 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
243 uint32_t tmp= *state << 8;
244 *state= tmp + *(p++);
245 if(tmp == 0x100 || p==end)
250 if (p[-1] > 1 ) p+= 3;
251 else if(p[-2] ) p+= 2;
252 else if(p[-3]|(p[-1]-1)) p++;
260 *state= be2me_32(unaligned32(p));
265 /* init common dct for both encoder and decoder */
266 int DCT_common_init(MpegEncContext *s)
268 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
269 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
270 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
271 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
273 if(s->flags & CODEC_FLAG_BITEXACT)
274 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
275 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
277 #ifdef CONFIG_ENCODERS
278 s->dct_quantize= dct_quantize_c;
279 s->denoise_dct= denoise_dct_c;
280 #endif //CONFIG_ENCODERS
283 MPV_common_init_mmx(s);
286 MPV_common_init_axp(s);
289 MPV_common_init_mlib(s);
292 MPV_common_init_mmi(s);
295 MPV_common_init_armv4l(s);
298 MPV_common_init_ppc(s);
301 #ifdef CONFIG_ENCODERS
302 s->fast_dct_quantize= s->dct_quantize;
304 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
305 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
308 #endif //CONFIG_ENCODERS
310 /* load & permutate scantables
311 note: only wmv uses different ones
313 if(s->alternate_scan){
314 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
317 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
320 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
321 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
326 static void copy_picture(Picture *dst, Picture *src){
328 dst->type= FF_BUFFER_TYPE_COPY;
331 #ifdef CONFIG_ENCODERS
332 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
335 dst->pict_type = src->pict_type;
336 dst->quality = src->quality;
337 dst->coded_picture_number = src->coded_picture_number;
338 dst->display_picture_number = src->display_picture_number;
339 // dst->reference = src->reference;
341 dst->interlaced_frame = src->interlaced_frame;
342 dst->top_field_first = src->top_field_first;
344 if(s->avctx->me_threshold){
345 if(!src->motion_val[0])
346 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
349 if(!src->ref_index[0])
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
351 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
352 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
353 src->motion_subsample_log2, dst->motion_subsample_log2);
355 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
358 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
359 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
361 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
362 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
364 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
365 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
373 * allocates a Picture
374 * The pixels are allocated/set by calling get_buffer() if shared=0
376 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
377 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
378 const int mb_array_size= s->mb_stride*s->mb_height;
379 const int b8_array_size= s->b8_stride*s->mb_height*2;
380 const int b4_array_size= s->b4_stride*s->mb_height*4;
384 assert(pic->data[0]);
385 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
386 pic->type= FF_BUFFER_TYPE_SHARED;
390 assert(!pic->data[0]);
392 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
394 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
399 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
404 if(pic->linesize[1] != pic->linesize[2]){
405 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
409 s->linesize = pic->linesize[0];
410 s->uvlinesize= pic->linesize[1];
413 if(pic->qscale_table==NULL){
415 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
416 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
417 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
420 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
421 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
422 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
423 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
424 if(s->out_format == FMT_H264){
426 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
427 pic->motion_val[i]= pic->motion_val_base[i]+4;
428 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
430 pic->motion_subsample_log2= 2;
431 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
433 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
434 pic->motion_val[i]= pic->motion_val_base[i]+4;
435 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
437 pic->motion_subsample_log2= 3;
439 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
440 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
442 pic->qstride= s->mb_stride;
443 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
446 //it might be nicer if the application would keep track of these but it would require a API change
447 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
448 s->prev_pict_types[0]= s->pict_type;
449 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
450 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
453 fail: //for the CHECKED_ALLOCZ macro
458 * deallocates a picture
460 static void free_picture(MpegEncContext *s, Picture *pic){
463 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
464 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
467 av_freep(&pic->mb_var);
468 av_freep(&pic->mc_mb_var);
469 av_freep(&pic->mb_mean);
470 av_freep(&pic->mbskip_table);
471 av_freep(&pic->qscale_table);
472 av_freep(&pic->mb_type_base);
473 av_freep(&pic->dct_coeff);
474 av_freep(&pic->pan_scan);
477 av_freep(&pic->motion_val_base[i]);
478 av_freep(&pic->ref_index[i]);
481 if(pic->type == FF_BUFFER_TYPE_SHARED){
490 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
493 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
494 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
495 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
497 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
498 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
499 s->rd_scratchpad= s->me.scratchpad;
500 s->b_scratchpad= s->me.scratchpad;
501 s->obmc_scratchpad= s->me.scratchpad + 16;
503 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
504 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
505 if(s->avctx->noise_reduction){
506 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
509 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
510 s->block= s->blocks[0];
513 s->pblocks[i] = (short *)(&s->block[i]);
517 return -1; //free() through MPV_common_end()
520 static void free_duplicate_context(MpegEncContext *s){
523 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
524 av_freep(&s->me.scratchpad);
527 s->obmc_scratchpad= NULL;
529 av_freep(&s->dct_error_sum);
530 av_freep(&s->me.map);
531 av_freep(&s->me.score_map);
532 av_freep(&s->blocks);
536 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
537 #define COPY(a) bak->a= src->a
538 COPY(allocated_edge_emu_buffer);
539 COPY(edge_emu_buffer);
543 COPY(obmc_scratchpad);
550 COPY(me.map_generation);
558 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
561 //FIXME copy only needed parts
563 backup_duplicate_context(&bak, dst);
564 memcpy(dst, src, sizeof(MpegEncContext));
565 backup_duplicate_context(dst, &bak);
567 dst->pblocks[i] = (short *)(&dst->block[i]);
569 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
572 #ifdef CONFIG_ENCODERS
573 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
574 #define COPY(a) dst->a= src->a
576 COPY(current_picture);
582 COPY(picture_in_gop_number);
583 COPY(gop_picture_number);
584 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
585 COPY(progressive_frame); //FIXME don't set in encode_header
586 COPY(partitioned_frame); //FIXME don't set in encode_header
592 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
593 * the changed fields will not depend upon the prior state of the MpegEncContext.
595 static void MPV_common_defaults(MpegEncContext *s){
597 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
598 s->chroma_qscale_table= ff_default_chroma_qscale_table;
599 s->progressive_frame= 1;
600 s->progressive_sequence= 1;
601 s->picture_structure= PICT_FRAME;
603 s->coded_picture_number = 0;
604 s->picture_number = 0;
605 s->input_picture_number = 0;
607 s->picture_in_gop_number = 0;
614 * sets the given MpegEncContext to defaults for decoding.
615 * the changed fields will not depend upon the prior state of the MpegEncContext.
617 void MPV_decode_defaults(MpegEncContext *s){
618 MPV_common_defaults(s);
622 * sets the given MpegEncContext to defaults for encoding.
623 * the changed fields will not depend upon the prior state of the MpegEncContext.
626 #ifdef CONFIG_ENCODERS
627 static void MPV_encode_defaults(MpegEncContext *s){
630 MPV_common_defaults(s);
636 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
637 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
639 for(i=-16; i<16; i++){
640 default_fcode_tab[i + MAX_MV]= 1;
643 s->me.mv_penalty= default_mv_penalty;
644 s->fcode_tab= default_fcode_tab;
646 #endif //CONFIG_ENCODERS
649 * init common structure for both encoder and decoder.
650 * this assumes that some variables like width/height are already set
652 int MPV_common_init(MpegEncContext *s)
654 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
656 s->mb_height = (s->height + 15) / 16;
658 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
659 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
663 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
666 dsputil_init(&s->dsp, s->avctx);
669 s->flags= s->avctx->flags;
670 s->flags2= s->avctx->flags2;
672 s->mb_width = (s->width + 15) / 16;
673 s->mb_stride = s->mb_width + 1;
674 s->b8_stride = s->mb_width*2 + 1;
675 s->b4_stride = s->mb_width*4 + 1;
676 mb_array_size= s->mb_height * s->mb_stride;
677 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
679 /* set chroma shifts */
680 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
681 &(s->chroma_y_shift) );
683 /* set default edge pos, will be overriden in decode_header if needed */
684 s->h_edge_pos= s->mb_width*16;
685 s->v_edge_pos= s->mb_height*16;
687 s->mb_num = s->mb_width * s->mb_height;
692 s->block_wrap[3]= s->b8_stride;
694 s->block_wrap[5]= s->mb_stride;
696 y_size = s->b8_stride * (2 * s->mb_height + 1);
697 c_size = s->mb_stride * (s->mb_height + 1);
698 yc_size = y_size + 2 * c_size;
700 /* convert fourcc to upper case */
701 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
702 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
703 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
704 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
706 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
707 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
708 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
709 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
711 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
713 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
714 for(y=0; y<s->mb_height; y++){
715 for(x=0; x<s->mb_width; x++){
716 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
719 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
722 /* Allocate MV tables */
723 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
724 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
725 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
726 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
727 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
728 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
729 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
730 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
731 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
732 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
733 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
734 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
736 if(s->msmpeg4_version){
737 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
739 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
741 /* Allocate MB type table */
742 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
744 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
746 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
747 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
748 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
749 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
750 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
751 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
753 if(s->avctx->noise_reduction){
754 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
757 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
759 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
761 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
762 /* interlaced direct mode decoding tables */
767 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
768 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
770 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
771 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
772 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
774 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
777 if (s->out_format == FMT_H263) {
779 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
780 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
781 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
782 s->ac_val[2] = s->ac_val[1] + c_size;
785 CHECKED_ALLOCZ(s->coded_block_base, y_size);
786 s->coded_block= s->coded_block_base + s->b8_stride + 1;
788 /* cbp, ac_pred, pred_dir */
789 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
790 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
793 if (s->h263_pred || s->h263_plus || !s->encoding) {
795 //MN: we need these for error resilience of intra-frames
796 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
797 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
798 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
799 s->dc_val[2] = s->dc_val[1] + c_size;
800 for(i=0;i<yc_size;i++)
801 s->dc_val_base[i] = 1024;
804 /* which mb is a intra block */
805 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
806 memset(s->mbintra_table, 1, mb_array_size);
808 /* init macroblock skip table */
809 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
810 //Note the +1 is for a quicker mpeg4 slice_end detection
811 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
813 s->parse_context.state= -1;
814 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
815 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
816 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
817 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
820 s->context_initialized = 1;
822 s->thread_context[0]= s;
823 for(i=1; i<s->avctx->thread_count; i++){
824 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
825 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
828 for(i=0; i<s->avctx->thread_count; i++){
829 if(init_duplicate_context(s->thread_context[i], s) < 0)
831 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
832 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
841 /* init common structure for both encoder and decoder */
842 void MPV_common_end(MpegEncContext *s)
846 for(i=0; i<s->avctx->thread_count; i++){
847 free_duplicate_context(s->thread_context[i]);
849 for(i=1; i<s->avctx->thread_count; i++){
850 av_freep(&s->thread_context[i]);
853 av_freep(&s->parse_context.buffer);
854 s->parse_context.buffer_size=0;
856 av_freep(&s->mb_type);
857 av_freep(&s->p_mv_table_base);
858 av_freep(&s->b_forw_mv_table_base);
859 av_freep(&s->b_back_mv_table_base);
860 av_freep(&s->b_bidir_forw_mv_table_base);
861 av_freep(&s->b_bidir_back_mv_table_base);
862 av_freep(&s->b_direct_mv_table_base);
864 s->b_forw_mv_table= NULL;
865 s->b_back_mv_table= NULL;
866 s->b_bidir_forw_mv_table= NULL;
867 s->b_bidir_back_mv_table= NULL;
868 s->b_direct_mv_table= NULL;
872 av_freep(&s->b_field_mv_table_base[i][j][k]);
873 s->b_field_mv_table[i][j][k]=NULL;
875 av_freep(&s->b_field_select_table[i][j]);
876 av_freep(&s->p_field_mv_table_base[i][j]);
877 s->p_field_mv_table[i][j]=NULL;
879 av_freep(&s->p_field_select_table[i]);
882 av_freep(&s->dc_val_base);
883 av_freep(&s->ac_val_base);
884 av_freep(&s->coded_block_base);
885 av_freep(&s->mbintra_table);
886 av_freep(&s->cbp_table);
887 av_freep(&s->pred_dir_table);
889 av_freep(&s->mbskip_table);
890 av_freep(&s->prev_pict_types);
891 av_freep(&s->bitstream_buffer);
892 s->allocated_bitstream_buffer_size=0;
894 av_freep(&s->avctx->stats_out);
895 av_freep(&s->ac_stats);
896 av_freep(&s->error_status_table);
897 av_freep(&s->mb_index2xy);
898 av_freep(&s->lambda_table);
899 av_freep(&s->q_intra_matrix);
900 av_freep(&s->q_inter_matrix);
901 av_freep(&s->q_intra_matrix16);
902 av_freep(&s->q_inter_matrix16);
903 av_freep(&s->input_picture);
904 av_freep(&s->reordered_input_picture);
905 av_freep(&s->dct_offset);
908 for(i=0; i<MAX_PICTURE_COUNT; i++){
909 free_picture(s, &s->picture[i]);
912 av_freep(&s->picture);
913 s->context_initialized = 0;
916 s->current_picture_ptr= NULL;
917 s->linesize= s->uvlinesize= 0;
920 av_freep(&s->visualization_buffer[i]);
922 avcodec_default_free_buffers(s->avctx);
925 #ifdef CONFIG_ENCODERS
927 /* init video encoder */
928 int MPV_encode_init(AVCodecContext *avctx)
930 MpegEncContext *s = avctx->priv_data;
932 int chroma_h_shift, chroma_v_shift;
934 MPV_encode_defaults(s);
936 switch (avctx->codec_id) {
937 case CODEC_ID_MPEG2VIDEO:
938 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
939 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
945 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
946 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
947 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
952 if(avctx->pix_fmt != PIX_FMT_YUV420P){
953 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
958 switch (avctx->pix_fmt) {
959 case PIX_FMT_YUVJ422P:
960 case PIX_FMT_YUV422P:
961 s->chroma_format = CHROMA_422;
963 case PIX_FMT_YUVJ420P:
964 case PIX_FMT_YUV420P:
966 s->chroma_format = CHROMA_420;
970 s->bit_rate = avctx->bit_rate;
971 s->width = avctx->width;
972 s->height = avctx->height;
973 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
974 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
977 s->gop_size = avctx->gop_size;
979 s->flags= avctx->flags;
980 s->flags2= avctx->flags2;
981 s->max_b_frames= avctx->max_b_frames;
982 s->codec_id= avctx->codec->id;
983 s->luma_elim_threshold = avctx->luma_elim_threshold;
984 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
985 s->strict_std_compliance= avctx->strict_std_compliance;
986 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
987 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
988 s->mpeg_quant= avctx->mpeg_quant;
989 s->rtp_mode= !!avctx->rtp_payload_size;
990 s->intra_dc_precision= avctx->intra_dc_precision;
991 s->user_specified_pts = AV_NOPTS_VALUE;
993 if (s->gop_size <= 1) {
1000 s->me_method = avctx->me_method;
1003 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
1005 s->adaptive_quant= ( s->avctx->lumi_masking
1006 || s->avctx->dark_masking
1007 || s->avctx->temporal_cplx_masking
1008 || s->avctx->spatial_cplx_masking
1009 || s->avctx->p_masking
1010 || s->avctx->border_masking
1011 || (s->flags&CODEC_FLAG_QP_RD))
1012 && !s->fixed_qscale;
1014 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1015 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1016 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1017 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1019 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1020 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1024 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1025 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1028 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1029 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1033 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1034 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1038 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1039 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1040 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1042 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");
1045 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1046 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1047 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1051 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1052 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1056 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1057 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1061 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1062 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1066 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1067 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1071 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1072 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1076 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1077 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1078 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1082 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1083 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1087 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1088 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1092 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1093 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1097 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1098 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1102 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1103 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1107 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1108 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1109 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1110 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1114 if(s->avctx->thread_count > 1)
1117 if(!avctx->time_base.den || !avctx->time_base.num){
1118 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1122 i= (INT_MAX/2+128)>>8;
1123 if(avctx->me_threshold >= i){
1124 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1127 if(avctx->mb_threshold >= i){
1128 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1132 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1133 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1134 avctx->b_frame_strategy = 0;
1137 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1139 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1140 avctx->time_base.den /= i;
1141 avctx->time_base.num /= i;
1145 if(s->codec_id==CODEC_ID_MJPEG){
1146 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1147 s->inter_quant_bias= 0;
1148 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1149 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1150 s->inter_quant_bias= 0;
1152 s->intra_quant_bias=0;
1153 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1156 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1157 s->intra_quant_bias= avctx->intra_quant_bias;
1158 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1159 s->inter_quant_bias= avctx->inter_quant_bias;
1161 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1163 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1164 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1167 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1169 switch(avctx->codec->id) {
1170 case CODEC_ID_MPEG1VIDEO:
1171 s->out_format = FMT_MPEG1;
1172 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1173 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1175 case CODEC_ID_MPEG2VIDEO:
1176 s->out_format = FMT_MPEG1;
1177 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1178 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1181 case CODEC_ID_LJPEG:
1182 case CODEC_ID_JPEGLS:
1183 case CODEC_ID_MJPEG:
1184 s->out_format = FMT_MJPEG;
1185 s->intra_only = 1; /* force intra only for jpeg */
1186 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1187 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1188 s->mjpeg_vsample[0] = 2;
1189 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1190 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1191 s->mjpeg_hsample[0] = 2;
1192 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1193 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1194 if (mjpeg_init(s) < 0)
1200 s->out_format = FMT_H261;
1205 if (h263_get_picture_format(s->width, s->height) == 7) {
1206 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);
1209 s->out_format = FMT_H263;
1210 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1214 case CODEC_ID_H263P:
1215 s->out_format = FMT_H263;
1218 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1219 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1220 s->modified_quant= s->h263_aic;
1221 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1222 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1223 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1224 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1225 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1228 /* These are just to be sure */
1233 s->out_format = FMT_H263;
1234 s->h263_flv = 2; /* format = 1; 11-bit codes */
1235 s->unrestricted_mv = 1;
1236 s->rtp_mode=0; /* don't allow GOB */
1241 s->out_format = FMT_H263;
1246 s->out_format = FMT_H263;
1249 s->modified_quant=1;
1253 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1255 case CODEC_ID_MPEG4:
1256 s->out_format = FMT_H263;
1258 s->unrestricted_mv = 1;
1259 s->low_delay= s->max_b_frames ? 0 : 1;
1260 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1262 case CODEC_ID_MSMPEG4V1:
1263 s->out_format = FMT_H263;
1264 s->h263_msmpeg4 = 1;
1266 s->unrestricted_mv = 1;
1267 s->msmpeg4_version= 1;
1271 case CODEC_ID_MSMPEG4V2:
1272 s->out_format = FMT_H263;
1273 s->h263_msmpeg4 = 1;
1275 s->unrestricted_mv = 1;
1276 s->msmpeg4_version= 2;
1280 case CODEC_ID_MSMPEG4V3:
1281 s->out_format = FMT_H263;
1282 s->h263_msmpeg4 = 1;
1284 s->unrestricted_mv = 1;
1285 s->msmpeg4_version= 3;
1286 s->flipflop_rounding=1;
1291 s->out_format = FMT_H263;
1292 s->h263_msmpeg4 = 1;
1294 s->unrestricted_mv = 1;
1295 s->msmpeg4_version= 4;
1296 s->flipflop_rounding=1;
1301 s->out_format = FMT_H263;
1302 s->h263_msmpeg4 = 1;
1304 s->unrestricted_mv = 1;
1305 s->msmpeg4_version= 5;
1306 s->flipflop_rounding=1;
1314 avctx->has_b_frames= !s->low_delay;
1319 if (MPV_common_init(s) < 0)
1322 if(s->modified_quant)
1323 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1324 s->progressive_frame=
1325 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1326 s->quant_precision=5;
1328 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1329 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1331 #ifdef CONFIG_H261_ENCODER
1332 if (s->out_format == FMT_H261)
1333 ff_h261_encode_init(s);
1335 if (s->out_format == FMT_H263)
1336 h263_encode_init(s);
1337 if(s->msmpeg4_version)
1338 ff_msmpeg4_encode_init(s);
1339 if (s->out_format == FMT_MPEG1)
1340 ff_mpeg1_encode_init(s);
1344 int j= s->dsp.idct_permutation[i];
1345 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1346 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1347 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1348 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1349 s->intra_matrix[j] =
1350 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1353 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1354 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1356 if(s->avctx->intra_matrix)
1357 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1358 if(s->avctx->inter_matrix)
1359 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1362 /* precompute matrix */
1363 /* for mjpeg, we do include qscale in the matrix */
1364 if (s->out_format != FMT_MJPEG) {
1365 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1366 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1367 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1368 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1371 if(ff_rate_control_init(s) < 0)
1377 int MPV_encode_end(AVCodecContext *avctx)
1379 MpegEncContext *s = avctx->priv_data;
1381 ff_rate_control_uninit(s);
1384 if (s->out_format == FMT_MJPEG)
1387 av_freep(&avctx->extradata);
1392 #endif //CONFIG_ENCODERS
1394 void init_rl(RLTable *rl, int use_static)
1396 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1397 uint8_t index_run[MAX_RUN+1];
1398 int last, run, level, start, end, i;
1400 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1401 if(use_static && rl->max_level[0])
1404 /* compute max_level[], max_run[] and index_run[] */
1405 for(last=0;last<2;last++) {
1414 memset(max_level, 0, MAX_RUN + 1);
1415 memset(max_run, 0, MAX_LEVEL + 1);
1416 memset(index_run, rl->n, MAX_RUN + 1);
1417 for(i=start;i<end;i++) {
1418 run = rl->table_run[i];
1419 level = rl->table_level[i];
1420 if (index_run[run] == rl->n)
1422 if (level > max_level[run])
1423 max_level[run] = level;
1424 if (run > max_run[level])
1425 max_run[level] = run;
1428 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1430 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1431 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1433 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1435 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1436 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1438 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1440 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1441 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1445 /* draw the edges of width 'w' of an image of size width, height */
1446 //FIXME check that this is ok for mpeg4 interlaced
1447 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1449 uint8_t *ptr, *last_line;
1452 last_line = buf + (height - 1) * wrap;
1454 /* top and bottom */
1455 memcpy(buf - (i + 1) * wrap, buf, width);
1456 memcpy(last_line + (i + 1) * wrap, last_line, width);
1458 /* left and right */
1460 for(i=0;i<height;i++) {
1461 memset(ptr - w, ptr[0], w);
1462 memset(ptr + width, ptr[width-1], w);
1467 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1468 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1469 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1470 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1474 int ff_find_unused_picture(MpegEncContext *s, int shared){
1478 for(i=0; i<MAX_PICTURE_COUNT; i++){
1479 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1482 for(i=0; i<MAX_PICTURE_COUNT; i++){
1483 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1485 for(i=0; i<MAX_PICTURE_COUNT; i++){
1486 if(s->picture[i].data[0]==NULL) return i;
1494 static void update_noise_reduction(MpegEncContext *s){
1497 for(intra=0; intra<2; intra++){
1498 if(s->dct_count[intra] > (1<<16)){
1499 for(i=0; i<64; i++){
1500 s->dct_error_sum[intra][i] >>=1;
1502 s->dct_count[intra] >>= 1;
1505 for(i=0; i<64; i++){
1506 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);
1512 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1514 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1520 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1522 /* mark&release old frames */
1523 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1524 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1526 /* release forgotten pictures */
1527 /* if(mpeg124/h263) */
1529 for(i=0; i<MAX_PICTURE_COUNT; i++){
1530 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1531 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1532 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1539 /* release non reference frames */
1540 for(i=0; i<MAX_PICTURE_COUNT; i++){
1541 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1542 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1546 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1547 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1549 i= ff_find_unused_picture(s, 0);
1550 pic= (AVFrame*)&s->picture[i];
1553 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1554 && !s->dropable ? 3 : 0;
1556 pic->coded_picture_number= s->coded_picture_number++;
1558 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1561 s->current_picture_ptr= (Picture*)pic;
1562 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1563 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1566 s->current_picture_ptr->pict_type= s->pict_type;
1567 // if(s->flags && CODEC_FLAG_QSCALE)
1568 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1569 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1571 copy_picture(&s->current_picture, s->current_picture_ptr);
1573 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1574 if (s->pict_type != B_TYPE) {
1575 s->last_picture_ptr= s->next_picture_ptr;
1577 s->next_picture_ptr= s->current_picture_ptr;
1579 /* 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,
1580 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1581 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1582 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1583 s->pict_type, s->dropable);*/
1585 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1586 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1588 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1589 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1590 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1594 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1596 if(s->picture_structure!=PICT_FRAME){
1599 if(s->picture_structure == PICT_BOTTOM_FIELD){
1600 s->current_picture.data[i] += s->current_picture.linesize[i];
1602 s->current_picture.linesize[i] *= 2;
1603 s->last_picture.linesize[i] *=2;
1604 s->next_picture.linesize[i] *=2;
1609 s->hurry_up= s->avctx->hurry_up;
1610 s->error_resilience= avctx->error_resilience;
1612 /* set dequantizer, we can't do it during init as it might change for mpeg4
1613 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1614 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1615 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1616 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1617 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1618 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1619 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1621 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1622 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1625 if(s->dct_error_sum){
1626 assert(s->avctx->noise_reduction && s->encoding);
1628 update_noise_reduction(s);
1632 if(s->avctx->xvmc_acceleration)
1633 return XVMC_field_start(s, avctx);
1638 /* generic function for encode/decode called after a frame has been coded/decoded */
1639 void MPV_frame_end(MpegEncContext *s)
1642 /* draw edge for correct motion prediction if outside */
1644 //just to make sure that all data is rendered.
1645 if(s->avctx->xvmc_acceleration){
1649 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1650 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1651 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1652 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1656 s->last_pict_type = s->pict_type;
1657 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1658 if(s->pict_type!=B_TYPE){
1659 s->last_non_b_pict_type= s->pict_type;
1662 /* copy back current_picture variables */
1663 for(i=0; i<MAX_PICTURE_COUNT; i++){
1664 if(s->picture[i].data[0] == s->current_picture.data[0]){
1665 s->picture[i]= s->current_picture;
1669 assert(i<MAX_PICTURE_COUNT);
1673 /* release non-reference frames */
1674 for(i=0; i<MAX_PICTURE_COUNT; i++){
1675 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1676 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1680 // clear copies, to avoid confusion
1682 memset(&s->last_picture, 0, sizeof(Picture));
1683 memset(&s->next_picture, 0, sizeof(Picture));
1684 memset(&s->current_picture, 0, sizeof(Picture));
1686 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1690 * draws an line from (ex, ey) -> (sx, sy).
1691 * @param w width of the image
1692 * @param h height of the image
1693 * @param stride stride/linesize of the image
1694 * @param color color of the arrow
1696 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1699 sx= clip(sx, 0, w-1);
1700 sy= clip(sy, 0, h-1);
1701 ex= clip(ex, 0, w-1);
1702 ey= clip(ey, 0, h-1);
1704 buf[sy*stride + sx]+= color;
1706 if(FFABS(ex - sx) > FFABS(ey - sy)){
1708 FFSWAP(int, sx, ex);
1709 FFSWAP(int, sy, ey);
1711 buf+= sx + sy*stride;
1713 f= ((ey-sy)<<16)/ex;
1714 for(x= 0; x <= ex; x++){
1717 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1718 buf[(y+1)*stride + x]+= (color* fr )>>16;
1722 FFSWAP(int, sx, ex);
1723 FFSWAP(int, sy, ey);
1725 buf+= sx + sy*stride;
1727 if(ey) f= ((ex-sx)<<16)/ey;
1729 for(y= 0; y <= ey; y++){
1732 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1733 buf[y*stride + x+1]+= (color* fr )>>16;;
1739 * draws an arrow from (ex, ey) -> (sx, sy).
1740 * @param w width of the image
1741 * @param h height of the image
1742 * @param stride stride/linesize of the image
1743 * @param color color of the arrow
1745 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1748 sx= clip(sx, -100, w+100);
1749 sy= clip(sy, -100, h+100);
1750 ex= clip(ex, -100, w+100);
1751 ey= clip(ey, -100, h+100);
1756 if(dx*dx + dy*dy > 3*3){
1759 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1761 //FIXME subpixel accuracy
1762 rx= ROUNDED_DIV(rx*3<<4, length);
1763 ry= ROUNDED_DIV(ry*3<<4, length);
1765 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1766 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1768 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1772 * prints debuging info for the given picture.
1774 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1776 if(!pict || !pict->mb_type) return;
1778 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1781 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1782 switch (pict->pict_type) {
1783 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1784 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1785 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1786 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1787 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1788 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1790 for(y=0; y<s->mb_height; y++){
1791 for(x=0; x<s->mb_width; x++){
1792 if(s->avctx->debug&FF_DEBUG_SKIP){
1793 int count= s->mbskip_table[x + y*s->mb_stride];
1794 if(count>9) count=9;
1795 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1797 if(s->avctx->debug&FF_DEBUG_QP){
1798 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1800 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1801 int mb_type= pict->mb_type[x + y*s->mb_stride];
1802 //Type & MV direction
1804 av_log(s->avctx, AV_LOG_DEBUG, "P");
1805 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1806 av_log(s->avctx, AV_LOG_DEBUG, "A");
1807 else if(IS_INTRA4x4(mb_type))
1808 av_log(s->avctx, AV_LOG_DEBUG, "i");
1809 else if(IS_INTRA16x16(mb_type))
1810 av_log(s->avctx, AV_LOG_DEBUG, "I");
1811 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1812 av_log(s->avctx, AV_LOG_DEBUG, "d");
1813 else if(IS_DIRECT(mb_type))
1814 av_log(s->avctx, AV_LOG_DEBUG, "D");
1815 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1816 av_log(s->avctx, AV_LOG_DEBUG, "g");
1817 else if(IS_GMC(mb_type))
1818 av_log(s->avctx, AV_LOG_DEBUG, "G");
1819 else if(IS_SKIP(mb_type))
1820 av_log(s->avctx, AV_LOG_DEBUG, "S");
1821 else if(!USES_LIST(mb_type, 1))
1822 av_log(s->avctx, AV_LOG_DEBUG, ">");
1823 else if(!USES_LIST(mb_type, 0))
1824 av_log(s->avctx, AV_LOG_DEBUG, "<");
1826 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1827 av_log(s->avctx, AV_LOG_DEBUG, "X");
1832 av_log(s->avctx, AV_LOG_DEBUG, "+");
1833 else if(IS_16X8(mb_type))
1834 av_log(s->avctx, AV_LOG_DEBUG, "-");
1835 else if(IS_8X16(mb_type))
1836 av_log(s->avctx, AV_LOG_DEBUG, "|");
1837 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1838 av_log(s->avctx, AV_LOG_DEBUG, " ");
1840 av_log(s->avctx, AV_LOG_DEBUG, "?");
1843 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1844 av_log(s->avctx, AV_LOG_DEBUG, "=");
1846 av_log(s->avctx, AV_LOG_DEBUG, " ");
1848 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1850 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1854 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1855 const int shift= 1 + s->quarter_sample;
1859 int h_chroma_shift, v_chroma_shift;
1860 const int width = s->avctx->width;
1861 const int height= s->avctx->height;
1862 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1863 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1864 s->low_delay=0; //needed to see the vectors without trashing the buffers
1866 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1868 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1869 pict->data[i]= s->visualization_buffer[i];
1871 pict->type= FF_BUFFER_TYPE_COPY;
1874 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1876 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1877 const int mb_index= mb_x + mb_y*s->mb_stride;
1878 if((s->avctx->debug_mv) && pict->motion_val){
1880 for(type=0; type<3; type++){
1883 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1887 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1891 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1896 if(!USES_LIST(pict->mb_type[mb_index], direction))
1899 if(IS_8X8(pict->mb_type[mb_index])){
1902 int sx= mb_x*16 + 4 + 8*(i&1);
1903 int sy= mb_y*16 + 4 + 8*(i>>1);
1904 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1905 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1906 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1907 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1909 }else if(IS_16X8(pict->mb_type[mb_index])){
1913 int sy=mb_y*16 + 4 + 8*i;
1914 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1915 int mx=(pict->motion_val[direction][xy][0]>>shift);
1916 int my=(pict->motion_val[direction][xy][1]>>shift);
1918 if(IS_INTERLACED(pict->mb_type[mb_index]))
1921 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1923 }else if(IS_8X16(pict->mb_type[mb_index])){
1926 int sx=mb_x*16 + 4 + 8*i;
1928 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1929 int mx=(pict->motion_val[direction][xy][0]>>shift);
1930 int my=(pict->motion_val[direction][xy][1]>>shift);
1932 if(IS_INTERLACED(pict->mb_type[mb_index]))
1935 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1938 int sx= mb_x*16 + 8;
1939 int sy= mb_y*16 + 8;
1940 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1941 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1942 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1943 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1947 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1948 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1951 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1952 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1955 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1956 int mb_type= pict->mb_type[mb_index];
1959 #define COLOR(theta, r)\
1960 u= (int)(128 + r*cos(theta*3.141592/180));\
1961 v= (int)(128 + r*sin(theta*3.141592/180));
1965 if(IS_PCM(mb_type)){
1967 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1969 }else if(IS_INTRA4x4(mb_type)){
1971 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1973 }else if(IS_DIRECT(mb_type)){
1975 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1977 }else if(IS_GMC(mb_type)){
1979 }else if(IS_SKIP(mb_type)){
1981 }else if(!USES_LIST(mb_type, 1)){
1983 }else if(!USES_LIST(mb_type, 0)){
1986 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1990 u*= 0x0101010101010101ULL;
1991 v*= 0x0101010101010101ULL;
1993 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1994 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1998 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1999 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2000 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2002 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2004 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2006 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2007 int dm= 1 << (mv_sample_log2-2);
2009 int sx= mb_x*16 + 8*(i&1);
2010 int sy= mb_y*16 + 8*(i>>1);
2011 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2013 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2014 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2016 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2017 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2018 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2022 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2026 s->mbskip_table[mb_index]=0;
2032 #ifdef CONFIG_ENCODERS
2034 static int get_sae(uint8_t *src, int ref, int stride){
2038 for(y=0; y<16; y++){
2039 for(x=0; x<16; x++){
2040 acc+= FFABS(src[x+y*stride] - ref);
2047 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2054 for(y=0; y<h; y+=16){
2055 for(x=0; x<w; x+=16){
2056 int offset= x + y*stride;
2057 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2058 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2059 int sae = get_sae(src + offset, mean, stride);
2061 acc+= sae + 500 < sad;
2068 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2072 const int encoding_delay= s->max_b_frames;
2077 pic_arg->display_picture_number= s->input_picture_number++;
2079 if(pts != AV_NOPTS_VALUE){
2080 if(s->user_specified_pts != AV_NOPTS_VALUE){
2082 int64_t last= s->user_specified_pts;
2085 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2089 s->user_specified_pts= pts;
2091 if(s->user_specified_pts != AV_NOPTS_VALUE){
2092 s->user_specified_pts=
2093 pts= s->user_specified_pts + 1;
2094 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2096 pts= pic_arg->display_picture_number;
2102 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2103 if(pic_arg->linesize[0] != s->linesize) direct=0;
2104 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2105 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2107 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2110 i= ff_find_unused_picture(s, 1);
2112 pic= (AVFrame*)&s->picture[i];
2116 pic->data[i]= pic_arg->data[i];
2117 pic->linesize[i]= pic_arg->linesize[i];
2119 alloc_picture(s, (Picture*)pic, 1);
2121 i= ff_find_unused_picture(s, 0);
2123 pic= (AVFrame*)&s->picture[i];
2126 alloc_picture(s, (Picture*)pic, 0);
2128 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2129 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2130 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2133 int h_chroma_shift, v_chroma_shift;
2134 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2137 int src_stride= pic_arg->linesize[i];
2138 int dst_stride= i ? s->uvlinesize : s->linesize;
2139 int h_shift= i ? h_chroma_shift : 0;
2140 int v_shift= i ? v_chroma_shift : 0;
2141 int w= s->width >>h_shift;
2142 int h= s->height>>v_shift;
2143 uint8_t *src= pic_arg->data[i];
2144 uint8_t *dst= pic->data[i];
2146 if(!s->avctx->rc_buffer_size)
2147 dst +=INPLACE_OFFSET;
2149 if(src_stride==dst_stride)
2150 memcpy(dst, src, src_stride*h);
2153 memcpy(dst, src, w);
2161 copy_picture_attributes(s, pic, pic_arg);
2162 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2165 /* shift buffer entries */
2166 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2167 s->input_picture[i-1]= s->input_picture[i];
2169 s->input_picture[encoding_delay]= (Picture*)pic;
2174 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2179 for(plane=0; plane<3; plane++){
2180 const int stride= p->linesize[plane];
2181 const int bw= plane ? 1 : 2;
2182 for(y=0; y<s->mb_height*bw; y++){
2183 for(x=0; x<s->mb_width*bw; x++){
2184 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2185 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);
2187 switch(s->avctx->frame_skip_exp){
2188 case 0: score= FFMAX(score, v); break;
2189 case 1: score+= FFABS(v);break;
2190 case 2: score+= v*v;break;
2191 case 3: score64+= FFABS(v*v*(int64_t)v);break;
2192 case 4: score64+= v*v*(int64_t)(v*v);break;
2198 if(score) score64= score;
2200 if(score64 < s->avctx->frame_skip_threshold)
2202 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2207 static int estimate_best_b_count(MpegEncContext *s){
2208 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2209 AVCodecContext *c= avcodec_alloc_context();
2210 AVFrame input[FF_MAX_B_FRAMES+2];
2211 const int scale= s->avctx->brd_scale;
2212 int i, j, out_size, p_lambda, b_lambda, lambda2;
2213 int outbuf_size= s->width * s->height; //FIXME
2214 uint8_t *outbuf= av_malloc(outbuf_size);
2215 int64_t best_rd= INT64_MAX;
2216 int best_b_count= -1;
2218 assert(scale>=0 && scale <=3);
2221 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2222 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2223 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2224 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2226 c->width = s->width >> scale;
2227 c->height= s->height>> scale;
2228 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2229 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2230 c->mb_decision= s->avctx->mb_decision;
2231 c->me_cmp= s->avctx->me_cmp;
2232 c->mb_cmp= s->avctx->mb_cmp;
2233 c->me_sub_cmp= s->avctx->me_sub_cmp;
2234 c->pix_fmt = PIX_FMT_YUV420P;
2235 c->time_base= s->avctx->time_base;
2236 c->max_b_frames= s->max_b_frames;
2238 if (avcodec_open(c, codec) < 0)
2241 for(i=0; i<s->max_b_frames+2; i++){
2242 int ysize= c->width*c->height;
2243 int csize= (c->width/2)*(c->height/2);
2244 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2247 pre_input= *pre_input_ptr;
2249 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2250 pre_input.data[0]+=INPLACE_OFFSET;
2251 pre_input.data[1]+=INPLACE_OFFSET;
2252 pre_input.data[2]+=INPLACE_OFFSET;
2255 avcodec_get_frame_defaults(&input[i]);
2256 input[i].data[0]= av_malloc(ysize + 2*csize);
2257 input[i].data[1]= input[i].data[0] + ysize;
2258 input[i].data[2]= input[i].data[1] + csize;
2259 input[i].linesize[0]= c->width;
2260 input[i].linesize[1]=
2261 input[i].linesize[2]= c->width/2;
2263 if(!i || s->input_picture[i-1]){
2264 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2265 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2266 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2270 for(j=0; j<s->max_b_frames+1; j++){
2273 if(!s->input_picture[j])
2276 c->error[0]= c->error[1]= c->error[2]= 0;
2278 input[0].pict_type= I_TYPE;
2279 input[0].quality= 1 * FF_QP2LAMBDA;
2280 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2281 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2283 for(i=0; i<s->max_b_frames+1; i++){
2284 int is_p= i % (j+1) == j || i==s->max_b_frames;
2286 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2287 input[i+1].quality= is_p ? p_lambda : b_lambda;
2288 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2289 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2292 /* get the delayed frames */
2294 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2295 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2298 rd += c->error[0] + c->error[1] + c->error[2];
2310 for(i=0; i<s->max_b_frames+2; i++){
2311 av_freep(&input[i].data[0]);
2314 return best_b_count;
2317 static void select_input_picture(MpegEncContext *s){
2320 for(i=1; i<MAX_PICTURE_COUNT; i++)
2321 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2322 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2324 /* set next picture type & ordering */
2325 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2326 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2327 s->reordered_input_picture[0]= s->input_picture[0];
2328 s->reordered_input_picture[0]->pict_type= I_TYPE;
2329 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2333 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2334 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2335 //FIXME check that te gop check above is +-1 correct
2336 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2338 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2340 s->input_picture[0]->data[i]= NULL;
2341 s->input_picture[0]->type= 0;
2343 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2344 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2346 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2350 ff_vbv_update(s, 0);
2356 if(s->flags&CODEC_FLAG_PASS2){
2357 for(i=0; i<s->max_b_frames+1; i++){
2358 int pict_num= s->input_picture[0]->display_picture_number + i;
2360 if(pict_num >= s->rc_context.num_entries)
2362 if(!s->input_picture[i]){
2363 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2367 s->input_picture[i]->pict_type=
2368 s->rc_context.entry[pict_num].new_pict_type;
2372 if(s->avctx->b_frame_strategy==0){
2373 b_frames= s->max_b_frames;
2374 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2375 }else if(s->avctx->b_frame_strategy==1){
2376 for(i=1; i<s->max_b_frames+1; i++){
2377 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2378 s->input_picture[i]->b_frame_score=
2379 get_intra_count(s, s->input_picture[i ]->data[0],
2380 s->input_picture[i-1]->data[0], s->linesize) + 1;
2383 for(i=0; i<s->max_b_frames+1; i++){
2384 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2387 b_frames= FFMAX(0, i-1);
2390 for(i=0; i<b_frames+1; i++){
2391 s->input_picture[i]->b_frame_score=0;
2393 }else if(s->avctx->b_frame_strategy==2){
2394 b_frames= estimate_best_b_count(s);
2396 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2401 //static int b_count=0;
2402 //b_count+= b_frames;
2403 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2405 for(i= b_frames - 1; i>=0; i--){
2406 int type= s->input_picture[i]->pict_type;
2407 if(type && type != B_TYPE)
2410 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2411 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2414 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2415 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2416 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2418 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2420 s->input_picture[b_frames]->pict_type= I_TYPE;
2424 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2426 && s->input_picture[b_frames]->pict_type== I_TYPE)
2429 s->reordered_input_picture[0]= s->input_picture[b_frames];
2430 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2431 s->reordered_input_picture[0]->pict_type= P_TYPE;
2432 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2433 for(i=0; i<b_frames; i++){
2434 s->reordered_input_picture[i+1]= s->input_picture[i];
2435 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2436 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2441 if(s->reordered_input_picture[0]){
2442 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2444 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2446 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
2447 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2449 int i= ff_find_unused_picture(s, 0);
2450 Picture *pic= &s->picture[i];
2452 pic->reference = s->reordered_input_picture[0]->reference;
2453 alloc_picture(s, pic, 0);
2455 /* mark us unused / free shared pic */
2456 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2457 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2459 s->reordered_input_picture[0]->data[i]= NULL;
2460 s->reordered_input_picture[0]->type= 0;
2462 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2464 s->current_picture_ptr= pic;
2466 // input is not a shared pix -> reuse buffer for current_pix
2468 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2469 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2471 s->current_picture_ptr= s->reordered_input_picture[0];
2473 s->new_picture.data[i]+= INPLACE_OFFSET;
2476 copy_picture(&s->current_picture, s->current_picture_ptr);
2478 s->picture_number= s->new_picture.display_picture_number;
2479 //printf("dpn:%d\n", s->picture_number);
2481 memset(&s->new_picture, 0, sizeof(Picture));
2485 int MPV_encode_picture(AVCodecContext *avctx,
2486 unsigned char *buf, int buf_size, void *data)
2488 MpegEncContext *s = avctx->priv_data;
2489 AVFrame *pic_arg = data;
2490 int i, stuffing_count;
2492 for(i=0; i<avctx->thread_count; i++){
2493 int start_y= s->thread_context[i]->start_mb_y;
2494 int end_y= s->thread_context[i]-> end_mb_y;
2495 int h= s->mb_height;
2496 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2497 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2499 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2502 s->picture_in_gop_number++;
2504 if(load_input_picture(s, pic_arg) < 0)
2507 select_input_picture(s);
2510 if(s->new_picture.data[0]){
2511 s->pict_type= s->new_picture.pict_type;
2513 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2514 MPV_frame_start(s, avctx);
2516 if (encode_picture(s, s->picture_number) < 0)
2519 avctx->real_pict_num = s->picture_number;
2520 avctx->header_bits = s->header_bits;
2521 avctx->mv_bits = s->mv_bits;
2522 avctx->misc_bits = s->misc_bits;
2523 avctx->i_tex_bits = s->i_tex_bits;
2524 avctx->p_tex_bits = s->p_tex_bits;
2525 avctx->i_count = s->i_count;
2526 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2527 avctx->skip_count = s->skip_count;
2531 if (s->out_format == FMT_MJPEG)
2532 mjpeg_picture_trailer(s);
2534 if(avctx->rc_buffer_size){
2535 RateControlContext *rcc= &s->rc_context;
2536 int max_size= rcc->buffer_index/3;
2538 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2539 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2540 s->mb_skipped = 0; //done in MPV_frame_start()
2541 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2542 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2543 s->no_rounding ^= 1;
2545 if(s->pict_type!=B_TYPE){
2546 s->time_base= s->last_time_base;
2547 s->last_non_b_time= s->time - s->pp_time;
2549 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2550 for(i=0; i<avctx->thread_count; i++){
2551 PutBitContext *pb= &s->thread_context[i]->pb;
2552 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2557 assert(s->avctx->rc_max_rate);
2560 if(s->flags&CODEC_FLAG_PASS1)
2561 ff_write_pass1_stats(s);
2564 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2565 avctx->error[i] += s->current_picture_ptr->error[i];
2568 if(s->flags&CODEC_FLAG_PASS1)
2569 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2570 flush_put_bits(&s->pb);
2571 s->frame_bits = put_bits_count(&s->pb);
2573 stuffing_count= ff_vbv_update(s, s->frame_bits);
2575 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2576 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2580 switch(s->codec_id){
2581 case CODEC_ID_MPEG1VIDEO:
2582 case CODEC_ID_MPEG2VIDEO:
2583 while(stuffing_count--){
2584 put_bits(&s->pb, 8, 0);
2587 case CODEC_ID_MPEG4:
2588 put_bits(&s->pb, 16, 0);
2589 put_bits(&s->pb, 16, 0x1C3);
2590 stuffing_count -= 4;
2591 while(stuffing_count--){
2592 put_bits(&s->pb, 8, 0xFF);
2596 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2598 flush_put_bits(&s->pb);
2599 s->frame_bits = put_bits_count(&s->pb);
2602 /* update mpeg1/2 vbv_delay for CBR */
2603 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2604 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2607 assert(s->repeat_first_field==0);
2609 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2610 assert(vbv_delay < 0xFFFF);
2612 s->vbv_delay_ptr[0] &= 0xF8;
2613 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2614 s->vbv_delay_ptr[1] = vbv_delay>>5;
2615 s->vbv_delay_ptr[2] &= 0x07;
2616 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2618 s->total_bits += s->frame_bits;
2619 avctx->frame_bits = s->frame_bits;
2621 assert((pbBufPtr(&s->pb) == s->pb.buf));
2624 assert((s->frame_bits&7)==0);
2626 return s->frame_bits/8;
2629 #endif //CONFIG_ENCODERS
2631 static inline void gmc1_motion(MpegEncContext *s,
2632 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2633 uint8_t **ref_picture)
2636 int offset, src_x, src_y, linesize, uvlinesize;
2637 int motion_x, motion_y;
2640 motion_x= s->sprite_offset[0][0];
2641 motion_y= s->sprite_offset[0][1];
2642 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2643 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2644 motion_x<<=(3-s->sprite_warping_accuracy);
2645 motion_y<<=(3-s->sprite_warping_accuracy);
2646 src_x = clip(src_x, -16, s->width);
2647 if (src_x == s->width)
2649 src_y = clip(src_y, -16, s->height);
2650 if (src_y == s->height)
2653 linesize = s->linesize;
2654 uvlinesize = s->uvlinesize;
2656 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2658 if(s->flags&CODEC_FLAG_EMU_EDGE){
2659 if( (unsigned)src_x >= s->h_edge_pos - 17
2660 || (unsigned)src_y >= s->v_edge_pos - 17){
2661 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2662 ptr= s->edge_emu_buffer;
2666 if((motion_x|motion_y)&7){
2667 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2668 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2672 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2673 if (s->no_rounding){
2674 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2676 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2680 if(s->flags&CODEC_FLAG_GRAY) return;
2682 motion_x= s->sprite_offset[1][0];
2683 motion_y= s->sprite_offset[1][1];
2684 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2685 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2686 motion_x<<=(3-s->sprite_warping_accuracy);
2687 motion_y<<=(3-s->sprite_warping_accuracy);
2688 src_x = clip(src_x, -8, s->width>>1);
2689 if (src_x == s->width>>1)
2691 src_y = clip(src_y, -8, s->height>>1);
2692 if (src_y == s->height>>1)
2695 offset = (src_y * uvlinesize) + src_x;
2696 ptr = ref_picture[1] + offset;
2697 if(s->flags&CODEC_FLAG_EMU_EDGE){
2698 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2699 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2700 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);
2701 ptr= s->edge_emu_buffer;
2705 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2707 ptr = ref_picture[2] + offset;
2709 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);
2710 ptr= s->edge_emu_buffer;
2712 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2717 static inline void gmc_motion(MpegEncContext *s,
2718 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2719 uint8_t **ref_picture)
2722 int linesize, uvlinesize;
2723 const int a= s->sprite_warping_accuracy;
2726 linesize = s->linesize;
2727 uvlinesize = s->uvlinesize;
2729 ptr = ref_picture[0];
2731 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2732 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2734 s->dsp.gmc(dest_y, ptr, linesize, 16,
2737 s->sprite_delta[0][0], s->sprite_delta[0][1],
2738 s->sprite_delta[1][0], s->sprite_delta[1][1],
2739 a+1, (1<<(2*a+1)) - s->no_rounding,
2740 s->h_edge_pos, s->v_edge_pos);
2741 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2742 ox + s->sprite_delta[0][0]*8,
2743 oy + s->sprite_delta[1][0]*8,
2744 s->sprite_delta[0][0], s->sprite_delta[0][1],
2745 s->sprite_delta[1][0], s->sprite_delta[1][1],
2746 a+1, (1<<(2*a+1)) - s->no_rounding,
2747 s->h_edge_pos, s->v_edge_pos);
2749 if(s->flags&CODEC_FLAG_GRAY) return;
2751 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2752 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2754 ptr = ref_picture[1];
2755 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2758 s->sprite_delta[0][0], s->sprite_delta[0][1],
2759 s->sprite_delta[1][0], s->sprite_delta[1][1],
2760 a+1, (1<<(2*a+1)) - s->no_rounding,
2761 s->h_edge_pos>>1, s->v_edge_pos>>1);
2763 ptr = ref_picture[2];
2764 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2767 s->sprite_delta[0][0], s->sprite_delta[0][1],
2768 s->sprite_delta[1][0], s->sprite_delta[1][1],
2769 a+1, (1<<(2*a+1)) - s->no_rounding,
2770 s->h_edge_pos>>1, s->v_edge_pos>>1);
2774 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2775 * @param buf destination buffer
2776 * @param src source buffer
2777 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2778 * @param block_w width of block
2779 * @param block_h height of block
2780 * @param src_x x coordinate of the top left sample of the block in the source buffer
2781 * @param src_y y coordinate of the top left sample of the block in the source buffer
2782 * @param w width of the source buffer
2783 * @param h height of the source buffer
2785 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2786 int src_x, int src_y, int w, int h){
2788 int start_y, start_x, end_y, end_x;
2791 src+= (h-1-src_y)*linesize;
2793 }else if(src_y<=-block_h){
2794 src+= (1-block_h-src_y)*linesize;
2800 }else if(src_x<=-block_w){
2801 src+= (1-block_w-src_x);
2805 start_y= FFMAX(0, -src_y);
2806 start_x= FFMAX(0, -src_x);
2807 end_y= FFMIN(block_h, h-src_y);
2808 end_x= FFMIN(block_w, w-src_x);
2810 // copy existing part
2811 for(y=start_y; y<end_y; y++){
2812 for(x=start_x; x<end_x; x++){
2813 buf[x + y*linesize]= src[x + y*linesize];
2818 for(y=0; y<start_y; y++){
2819 for(x=start_x; x<end_x; x++){
2820 buf[x + y*linesize]= buf[x + start_y*linesize];
2825 for(y=end_y; y<block_h; y++){
2826 for(x=start_x; x<end_x; x++){
2827 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2831 for(y=0; y<block_h; y++){
2833 for(x=0; x<start_x; x++){
2834 buf[x + y*linesize]= buf[start_x + y*linesize];
2838 for(x=end_x; x<block_w; x++){
2839 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2844 static inline int hpel_motion(MpegEncContext *s,
2845 uint8_t *dest, uint8_t *src,
2846 int field_based, int field_select,
2847 int src_x, int src_y,
2848 int width, int height, int stride,
2849 int h_edge_pos, int v_edge_pos,
2850 int w, int h, op_pixels_func *pix_op,
2851 int motion_x, int motion_y)
2856 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2857 src_x += motion_x >> 1;
2858 src_y += motion_y >> 1;
2860 /* WARNING: do no forget half pels */
2861 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2864 src_y = clip(src_y, -16, height);
2865 if (src_y == height)
2867 src += src_y * stride + src_x;
2869 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2870 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2871 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2872 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2873 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2874 src= s->edge_emu_buffer;
2880 pix_op[dxy](dest, src, stride, h);
2884 static inline int hpel_motion_lowres(MpegEncContext *s,
2885 uint8_t *dest, uint8_t *src,
2886 int field_based, int field_select,
2887 int src_x, int src_y,
2888 int width, int height, int stride,
2889 int h_edge_pos, int v_edge_pos,
2890 int w, int h, h264_chroma_mc_func *pix_op,
2891 int motion_x, int motion_y)
2893 const int lowres= s->avctx->lowres;
2894 const int s_mask= (2<<lowres)-1;
2898 if(s->quarter_sample){
2903 sx= motion_x & s_mask;
2904 sy= motion_y & s_mask;
2905 src_x += motion_x >> (lowres+1);
2906 src_y += motion_y >> (lowres+1);
2908 src += src_y * stride + src_x;
2910 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2911 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2912 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2913 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2914 src= s->edge_emu_buffer;
2922 pix_op[lowres](dest, src, stride, h, sx, sy);
2926 /* apply one mpeg motion vector to the three components */
2927 static always_inline void mpeg_motion(MpegEncContext *s,
2928 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2929 int field_based, int bottom_field, int field_select,
2930 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2931 int motion_x, int motion_y, int h)
2933 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2934 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2937 if(s->quarter_sample)
2944 v_edge_pos = s->v_edge_pos >> field_based;
2945 linesize = s->current_picture.linesize[0] << field_based;
2946 uvlinesize = s->current_picture.linesize[1] << field_based;
2948 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2949 src_x = s->mb_x* 16 + (motion_x >> 1);
2950 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2952 if (s->out_format == FMT_H263) {
2953 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2954 mx = (motion_x>>1)|(motion_x&1);
2956 uvdxy = ((my & 1) << 1) | (mx & 1);
2957 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2958 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2960 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2964 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2968 uvsrc_x = s->mb_x*8 + mx;
2969 uvsrc_y = s->mb_y*8 + my;
2971 if(s->chroma_y_shift){
2974 uvdxy = ((my & 1) << 1) | (mx & 1);
2975 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2976 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2978 if(s->chroma_x_shift){
2981 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2982 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2993 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2994 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2995 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2997 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2998 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2999 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3000 s->codec_id == CODEC_ID_MPEG1VIDEO){
3001 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3004 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3005 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3006 ptr_y = s->edge_emu_buffer;
3007 if(!(s->flags&CODEC_FLAG_GRAY)){
3008 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3009 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3010 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3011 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3012 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3018 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3019 dest_y += s->linesize;
3020 dest_cb+= s->uvlinesize;
3021 dest_cr+= s->uvlinesize;
3025 ptr_y += s->linesize;
3026 ptr_cb+= s->uvlinesize;
3027 ptr_cr+= s->uvlinesize;
3030 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3032 if(!(s->flags&CODEC_FLAG_GRAY)){
3033 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3034 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3036 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3037 if(s->out_format == FMT_H261){
3038 ff_h261_loop_filter(s);
3043 /* apply one mpeg motion vector to the three components */
3044 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3045 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3046 int field_based, int bottom_field, int field_select,
3047 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3048 int motion_x, int motion_y, int h)
3050 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3051 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3052 const int lowres= s->avctx->lowres;
3053 const int block_s= 8>>lowres;
3054 const int s_mask= (2<<lowres)-1;
3055 const int h_edge_pos = s->h_edge_pos >> lowres;
3056 const int v_edge_pos = s->v_edge_pos >> lowres;
3057 linesize = s->current_picture.linesize[0] << field_based;
3058 uvlinesize = s->current_picture.linesize[1] << field_based;
3060 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3066 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3069 sx= motion_x & s_mask;
3070 sy= motion_y & s_mask;
3071 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3072 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3074 if (s->out_format == FMT_H263) {
3075 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3076 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3079 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3082 uvsx = (2*mx) & s_mask;
3083 uvsy = (2*my) & s_mask;
3084 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3085 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3091 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3092 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3095 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3096 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3097 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3099 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3100 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3101 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3102 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3103 ptr_y = s->edge_emu_buffer;
3104 if(!(s->flags&CODEC_FLAG_GRAY)){
3105 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3106 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3107 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3108 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3109 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3115 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3116 dest_y += s->linesize;
3117 dest_cb+= s->uvlinesize;
3118 dest_cr+= s->uvlinesize;
3122 ptr_y += s->linesize;
3123 ptr_cb+= s->uvlinesize;
3124 ptr_cr+= s->uvlinesize;
3129 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3131 if(!(s->flags&CODEC_FLAG_GRAY)){
3132 uvsx <<= 2 - lowres;
3133 uvsy <<= 2 - lowres;
3134 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3135 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3137 //FIXME h261 lowres loop filter
3140 //FIXME move to dsputil, avg variant, 16x16 version
3141 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3143 uint8_t * const top = src[1];
3144 uint8_t * const left = src[2];
3145 uint8_t * const mid = src[0];
3146 uint8_t * const right = src[3];
3147 uint8_t * const bottom= src[4];
3148 #define OBMC_FILTER(x, t, l, m, r, b)\
3149 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3150 #define OBMC_FILTER4(x, t, l, m, r, b)\
3151 OBMC_FILTER(x , t, l, m, r, b);\
3152 OBMC_FILTER(x+1 , t, l, m, r, b);\
3153 OBMC_FILTER(x +stride, t, l, m, r, b);\
3154 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3157 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3158 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3159 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3160 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3161 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3162 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3164 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3165 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3166 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3167 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3169 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3170 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3171 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3172 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3174 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3175 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3176 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3177 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3179 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3180 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3181 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3182 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3183 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3184 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3186 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3187 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3188 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3189 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3192 /* obmc for 1 8x8 luma block */
3193 static inline void obmc_motion(MpegEncContext *s,
3194 uint8_t *dest, uint8_t *src,
3195 int src_x, int src_y,
3196 op_pixels_func *pix_op,
3197 int16_t mv[5][2]/* mid top left right bottom*/)
3203 assert(s->quarter_sample==0);
3206 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3209 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3210 hpel_motion(s, ptr[i], src, 0, 0,
3212 s->width, s->height, s->linesize,
3213 s->h_edge_pos, s->v_edge_pos,
3215 mv[i][0], mv[i][1]);
3219 put_obmc(dest, ptr, s->linesize);
3222 static inline void qpel_motion(MpegEncContext *s,
3223 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3224 int field_based, int bottom_field, int field_select,
3225 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3226 qpel_mc_func (*qpix_op)[16],
3227 int motion_x, int motion_y, int h)
3229 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3230 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3232 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3233 src_x = s->mb_x * 16 + (motion_x >> 2);
3234 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3236 v_edge_pos = s->v_edge_pos >> field_based;
3237 linesize = s->linesize << field_based;
3238 uvlinesize = s->uvlinesize << field_based;
3243 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3244 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3245 mx= (motion_x>>1) + rtab[motion_x&7];
3246 my= (motion_y>>1) + rtab[motion_y&7];
3247 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3248 mx= (motion_x>>1)|(motion_x&1);
3249 my= (motion_y>>1)|(motion_y&1);
3257 uvdxy= (mx&1) | ((my&1)<<1);
3261 uvsrc_x = s->mb_x * 8 + mx;
3262 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3264 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3265 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3266 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3268 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3269 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3270 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3271 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3272 ptr_y= s->edge_emu_buffer;
3273 if(!(s->flags&CODEC_FLAG_GRAY)){
3274 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3275 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3276 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3277 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3278 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3285 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3288 dest_y += s->linesize;
3289 dest_cb+= s->uvlinesize;
3290 dest_cr+= s->uvlinesize;
3294 ptr_y += s->linesize;
3295 ptr_cb += s->uvlinesize;
3296 ptr_cr += s->uvlinesize;
3298 //damn interlaced mode
3299 //FIXME boundary mirroring is not exactly correct here
3300 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3301 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3303 if(!(s->flags&CODEC_FLAG_GRAY)){
3304 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3305 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3309 inline int ff_h263_round_chroma(int x){
3311 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3314 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3319 * h263 chorma 4mv motion compensation.
3321 static inline void chroma_4mv_motion(MpegEncContext *s,
3322 uint8_t *dest_cb, uint8_t *dest_cr,
3323 uint8_t **ref_picture,
3324 op_pixels_func *pix_op,
3326 int dxy, emu=0, src_x, src_y, offset;
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);
3334 dxy = ((my & 1) << 1) | (mx & 1);
3338 src_x = s->mb_x * 8 + mx;
3339 src_y = s->mb_y * 8 + my;
3340 src_x = clip(src_x, -8, s->width/2);
3341 if (src_x == s->width/2)
3343 src_y = clip(src_y, -8, s->height/2);
3344 if (src_y == s->height/2)
3347 offset = (src_y * (s->uvlinesize)) + src_x;
3348 ptr = ref_picture[1] + offset;
3349 if(s->flags&CODEC_FLAG_EMU_EDGE){
3350 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3351 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3352 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);
3353 ptr= s->edge_emu_buffer;
3357 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3359 ptr = ref_picture[2] + offset;
3361 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);
3362 ptr= s->edge_emu_buffer;
3364 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3367 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3368 uint8_t *dest_cb, uint8_t *dest_cr,
3369 uint8_t **ref_picture,
3370 h264_chroma_mc_func *pix_op,
3372 const int lowres= s->avctx->lowres;
3373 const int block_s= 8>>lowres;
3374 const int s_mask= (2<<lowres)-1;
3375 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3376 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3377 int emu=0, src_x, src_y, offset, sx, sy;
3380 if(s->quarter_sample){
3385 /* In case of 8X8, we construct a single chroma motion vector
3386 with a special rounding */
3387 mx= ff_h263_round_chroma(mx);
3388 my= ff_h263_round_chroma(my);
3392 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3393 src_y = s->mb_y*block_s + (my >> (lowres+1));
3395 offset = src_y * s->uvlinesize + src_x;
3396 ptr = ref_picture[1] + offset;
3397 if(s->flags&CODEC_FLAG_EMU_EDGE){
3398 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3399 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3400 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3401 ptr= s->edge_emu_buffer;
3407 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3409 ptr = ref_picture[2] + offset;
3411 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3412 ptr= s->edge_emu_buffer;
3414 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3417 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3418 /* fetch pixels for estimated mv 4 macroblocks ahead
3419 * optimized for 64byte cache lines */
3420 const int shift = s->quarter_sample ? 2 : 1;
3421 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3422 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3423 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3424 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3425 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3426 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3430 * motion compensation of a single macroblock
3432 * @param dest_y luma destination pointer
3433 * @param dest_cb chroma cb/u destination pointer
3434 * @param dest_cr chroma cr/v destination pointer
3435 * @param dir direction (0->forward, 1->backward)
3436 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3437 * @param pic_op halfpel motion compensation function (average or put normally)
3438 * @param pic_op qpel motion compensation function (average or put normally)
3439 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3441 static inline void MPV_motion(MpegEncContext *s,
3442 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3443 int dir, uint8_t **ref_picture,
3444 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3446 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3448 uint8_t *ptr, *dest;
3453 prefetch_motion(s, ref_picture, dir);
3455 if(s->obmc && s->pict_type != B_TYPE){
3456 int16_t mv_cache[4][4][2];
3457 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3458 const int mot_stride= s->b8_stride;
3459 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3461 assert(!s->mb_skipped);
3463 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3464 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3465 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3467 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3468 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3470 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3473 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3474 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3475 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3477 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3478 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3481 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3482 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3483 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3485 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3486 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3492 const int x= (i&1)+1;
3493 const int y= (i>>1)+1;
3495 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3496 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3497 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3498 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3499 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3501 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3503 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3510 if(!(s->flags&CODEC_FLAG_GRAY))
3511 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3516 switch(s->mv_type) {
3519 if(s->real_sprite_warping_points==1){
3520 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3523 gmc_motion(s, dest_y, dest_cb, dest_cr,
3526 }else if(s->quarter_sample){
3527 qpel_motion(s, dest_y, dest_cb, dest_cr,
3529 ref_picture, pix_op, qpix_op,
3530 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3532 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3533 ref_picture, pix_op,
3534 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3537 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3539 ref_picture, pix_op,
3540 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3546 if(s->quarter_sample){
3548 motion_x = s->mv[dir][i][0];
3549 motion_y = s->mv[dir][i][1];
3551 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3552 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3553 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3555 /* WARNING: do no forget half pels */
3556 src_x = clip(src_x, -16, s->width);
3557 if (src_x == s->width)
3559 src_y = clip(src_y, -16, s->height);
3560 if (src_y == s->height)
3563 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3564 if(s->flags&CODEC_FLAG_EMU_EDGE){
3565 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3566 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3567 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);
3568 ptr= s->edge_emu_buffer;
3571 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3572 qpix_op[1][dxy](dest, ptr, s->linesize);
3574 mx += s->mv[dir][i][0]/2;
3575 my += s->mv[dir][i][1]/2;
3579 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3580 ref_picture[0], 0, 0,
3581 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3582 s->width, s->height, s->linesize,
3583 s->h_edge_pos, s->v_edge_pos,
3585 s->mv[dir][i][0], s->mv[dir][i][1]);
3587 mx += s->mv[dir][i][0];
3588 my += s->mv[dir][i][1];
3592 if(!(s->flags&CODEC_FLAG_GRAY))
3593 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3596 if (s->picture_structure == PICT_FRAME) {
3597 if(s->quarter_sample){
3599 qpel_motion(s, dest_y, dest_cb, dest_cr,
3600 1, i, s->field_select[dir][i],
3601 ref_picture, pix_op, qpix_op,
3602 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3606 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3607 1, 0, s->field_select[dir][0],
3608 ref_picture, pix_op,
3609 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3611 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3612 1, 1, s->field_select[dir][1],
3613 ref_picture, pix_op,
3614 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3617 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3618 ref_picture= s->current_picture_ptr->data;
3621 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3622 0, 0, s->field_select[dir][0],
3623 ref_picture, pix_op,
3624 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3629 uint8_t ** ref2picture;
3631 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3632 ref2picture= ref_picture;
3634 ref2picture= s->current_picture_ptr->data;
3637 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3638 0, 0, s->field_select[dir][i],
3639 ref2picture, pix_op,
3640 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3642 dest_y += 16*s->linesize;
3643 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3644 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3648 if(s->picture_structure == PICT_FRAME){
3652 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3654 ref_picture, pix_op,
3655 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3657 pix_op = s->dsp.avg_pixels_tab;
3661 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3662 0, 0, s->picture_structure != i+1,
3663 ref_picture, pix_op,
3664 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3666 // after put we make avg of the same block
3667 pix_op=s->dsp.avg_pixels_tab;
3669 //opposite parity is always in the same frame if this is second field
3670 if(!s->first_field){
3671 ref_picture = s->current_picture_ptr->data;
3681 * motion compensation of a single macroblock
3683 * @param dest_y luma destination pointer
3684 * @param dest_cb chroma cb/u destination pointer
3685 * @param dest_cr chroma cr/v destination pointer
3686 * @param dir direction (0->forward, 1->backward)
3687 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3688 * @param pic_op halfpel motion compensation function (average or put normally)
3689 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3691 static inline void MPV_motion_lowres(MpegEncContext *s,
3692 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3693 int dir, uint8_t **ref_picture,
3694 h264_chroma_mc_func *pix_op)
3698 const int lowres= s->avctx->lowres;
3699 const int block_s= 8>>lowres;
3704 switch(s->mv_type) {
3706 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3708 ref_picture, pix_op,
3709 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3715 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3716 ref_picture[0], 0, 0,
3717 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3718 s->width, s->height, s->linesize,
3719 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3720 block_s, block_s, pix_op,
3721 s->mv[dir][i][0], s->mv[dir][i][1]);
3723 mx += s->mv[dir][i][0];
3724 my += s->mv[dir][i][1];
3727 if(!(s->flags&CODEC_FLAG_GRAY))
3728 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3731 if (s->picture_structure == PICT_FRAME) {
3733 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3734 1, 0, s->field_select[dir][0],
3735 ref_picture, pix_op,
3736 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3738 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3739 1, 1, s->field_select[dir][1],
3740 ref_picture, pix_op,
3741 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3743 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3744 ref_picture= s->current_picture_ptr->data;
3747 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3748 0, 0, s->field_select[dir][0],
3749 ref_picture, pix_op,
3750 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3755 uint8_t ** ref2picture;
3757 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3758 ref2picture= ref_picture;
3760 ref2picture= s->current_picture_ptr->data;
3763 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3764 0, 0, s->field_select[dir][i],
3765 ref2picture, pix_op,
3766 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3768 dest_y += 2*block_s*s->linesize;
3769 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3770 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3774 if(s->picture_structure == PICT_FRAME){
3778 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3780 ref_picture, pix_op,
3781 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3783 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3787 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3788 0, 0, s->picture_structure != i+1,
3789 ref_picture, pix_op,
3790 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3792 // after put we make avg of the same block
3793 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3795 //opposite parity is always in the same frame if this is second field
3796 if(!s->first_field){
3797 ref_picture = s->current_picture_ptr->data;
3806 /* put block[] to dest[] */
3807 static inline void put_dct(MpegEncContext *s,
3808 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3810 s->dct_unquantize_intra(s, block, i, qscale);
3811 s->dsp.idct_put (dest, line_size, block);
3814 /* add block[] to dest[] */
3815 static inline void add_dct(MpegEncContext *s,
3816 DCTELEM *block, int i, uint8_t *dest, int line_size)
3818 if (s->block_last_index[i] >= 0) {
3819 s->dsp.idct_add (dest, line_size, block);
3823 static inline void add_dequant_dct(MpegEncContext *s,
3824 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3826 if (s->block_last_index[i] >= 0) {
3827 s->dct_unquantize_inter(s, block, i, qscale);
3829 s->dsp.idct_add (dest, line_size, block);
3834 * cleans dc, ac, coded_block for the current non intra MB
3836 void ff_clean_intra_table_entries(MpegEncContext *s)
3838 int wrap = s->b8_stride;
3839 int xy = s->block_index[0];
3842 s->dc_val[0][xy + 1 ] =
3843 s->dc_val[0][xy + wrap] =
3844 s->dc_val[0][xy + 1 + wrap] = 1024;
3846 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3847 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3848 if (s->msmpeg4_version>=3) {
3849 s->coded_block[xy ] =
3850 s->coded_block[xy + 1 ] =
3851 s->coded_block[xy + wrap] =
3852 s->coded_block[xy + 1 + wrap] = 0;
3855 wrap = s->mb_stride;
3856 xy = s->mb_x + s->mb_y * wrap;
3858 s->dc_val[2][xy] = 1024;
3860 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3861 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3863 s->mbintra_table[xy]= 0;
3866 /* generic function called after a macroblock has been parsed by the
3867 decoder or after it has been encoded by the encoder.
3869 Important variables used:
3870 s->mb_intra : true if intra macroblock
3871 s->mv_dir : motion vector direction
3872 s->mv_type : motion vector type
3873 s->mv : motion vector
3874 s->interlaced_dct : true if interlaced dct used (mpeg2)
3876 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3879 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3881 if(s->avctx->xvmc_acceleration){
3882 XVMC_decode_mb(s);//xvmc uses pblocks
3890 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3891 /* save DCT coefficients */
3893 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3896 *dct++ = block[i][s->dsp.idct_permutation[j]];
3899 s->current_picture.qscale_table[mb_xy]= s->qscale;
3901 /* update DC predictors for P macroblocks */
3903 if (s->h263_pred || s->h263_aic) {
3904 if(s->mbintra_table[mb_xy])
3905 ff_clean_intra_table_entries(s);
3909 s->last_dc[2] = 128 << s->intra_dc_precision;
3912 else if (s->h263_pred || s->h263_aic)
3913 s->mbintra_table[mb_xy]=1;
3915 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3916 uint8_t *dest_y, *dest_cb, *dest_cr;
3917 int dct_linesize, dct_offset;
3918 op_pixels_func (*op_pix)[4];
3919 qpel_mc_func (*op_qpix)[16];
3920 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3921 const int uvlinesize= s->current_picture.linesize[1];
3922 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3923 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3925 /* avoid copy if macroblock skipped in last frame too */
3926 /* skip only during decoding as we might trash the buffers during encoding a bit */
3928 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3929 const int age= s->current_picture.age;
3933 if (s->mb_skipped) {
3935 assert(s->pict_type!=I_TYPE);
3937 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3938 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3940 /* if previous was skipped too, then nothing to do ! */
3941 if (*mbskip_ptr >= age && s->current_picture.reference){
3944 } else if(!s->current_picture.reference){
3945 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3946 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3948 *mbskip_ptr = 0; /* not skipped */
3952 dct_linesize = linesize << s->interlaced_dct;
3953 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3957 dest_cb= s->dest[1];
3958 dest_cr= s->dest[2];
3960 dest_y = s->b_scratchpad;
3961 dest_cb= s->b_scratchpad+16*linesize;
3962 dest_cr= s->b_scratchpad+32*linesize;
3966 /* motion handling */
3967 /* decoding or more than one mb_type (MC was already done otherwise) */
3970 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3972 if (s->mv_dir & MV_DIR_FORWARD) {
3973 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3974 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3976 if (s->mv_dir & MV_DIR_BACKWARD) {
3977 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3980 op_qpix= s->me.qpel_put;
3981 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3982 op_pix = s->dsp.put_pixels_tab;
3984 op_pix = s->dsp.put_no_rnd_pixels_tab;
3986 if (s->mv_dir & MV_DIR_FORWARD) {
3987 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3988 op_pix = s->dsp.avg_pixels_tab;
3989 op_qpix= s->me.qpel_avg;
3991 if (s->mv_dir & MV_DIR_BACKWARD) {
3992 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3997 /* skip dequant / idct if we are really late ;) */
3998 if(s->hurry_up>1) goto skip_idct;
3999 if(s->avctx->skip_idct){
4000 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
4001 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
4002 || s->avctx->skip_idct >= AVDISCARD_ALL)
4006 /* add dct residue */
4007 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
4008 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
4009 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4010 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4011 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4012 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4014 if(!(s->flags&CODEC_FLAG_GRAY)){
4015 if (s->chroma_y_shift){
4016 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4017 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4021 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4022 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4023 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4024 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4027 } else if(s->codec_id != CODEC_ID_WMV2){
4028 add_dct(s, block[0], 0, dest_y , dct_linesize);
4029 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
4030 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
4031 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
4033 if(!(s->flags&CODEC_FLAG_GRAY)){
4034 if(s->chroma_y_shift){//Chroma420
4035 add_dct(s, block[4], 4, dest_cb, uvlinesize);
4036 add_dct(s, block[5], 5, dest_cr, uvlinesize);
4039 dct_linesize = uvlinesize << s->interlaced_dct;
4040 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4042 add_dct(s, block[4], 4, dest_cb, dct_linesize);
4043 add_dct(s, block[5], 5, dest_cr, dct_linesize);
4044 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4045 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4046 if(!s->chroma_x_shift){//Chroma444
4047 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4048 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4049 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4050 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4056 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4059 /* dct only in intra block */
4060 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4061 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4062 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4063 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4064 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4066 if(!(s->flags&CODEC_FLAG_GRAY)){
4067 if(s->chroma_y_shift){
4068 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4069 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4073 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4074 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4075 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4076 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4080 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
4081 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
4082 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
4083 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4085 if(!(s->flags&CODEC_FLAG_GRAY)){
4086 if(s->chroma_y_shift){
4087 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4088 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4091 dct_linesize = uvlinesize << s->interlaced_dct;
4092 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4094 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4095 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4096 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4097 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4098 if(!s->chroma_x_shift){//Chroma444
4099 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4100 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4101 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4102 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4110 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4111 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4112 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4117 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4118 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4119 else MPV_decode_mb_internal(s, block, 0);
4122 #ifdef CONFIG_ENCODERS
4124 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4126 static const char tab[64]=
4138 DCTELEM *block= s->block[n];
4139 const int last_index= s->block_last_index[n];
4144 threshold= -threshold;
4148 /* are all which we could set to zero are allready zero? */
4149 if(last_index<=skip_dc - 1) return;
4151 for(i=0; i<=last_index; i++){
4152 const int j = s->intra_scantable.permutated[i];
4153 const int level = FFABS(block[j]);
4155 if(skip_dc && i==0) continue;
4164 if(score >= threshold) return;
4165 for(i=skip_dc; i<=last_index; i++){
4166 const int j = s->intra_scantable.permutated[i];
4169 if(block[0]) s->block_last_index[n]= 0;
4170 else s->block_last_index[n]= -1;
4173 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4176 const int maxlevel= s->max_qcoeff;
4177 const int minlevel= s->min_qcoeff;
4181 i=1; //skip clipping of intra dc
4185 for(;i<=last_index; i++){
4186 const int j= s->intra_scantable.permutated[i];
4187 int level = block[j];
4189 if (level>maxlevel){
4192 }else if(level<minlevel){
4200 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4201 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4204 #endif //CONFIG_ENCODERS
4208 * @param h is the normal height, this will be reduced automatically if needed for the last row
4210 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4211 if (s->avctx->draw_horiz_band) {
4215 if(s->picture_structure != PICT_FRAME){
4218 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4221 h= FFMIN(h, s->avctx->height - y);
4223 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4224 src= (AVFrame*)s->current_picture_ptr;
4225 else if(s->last_picture_ptr)
4226 src= (AVFrame*)s->last_picture_ptr;
4230 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4236 offset[0]= y * s->linesize;;
4238 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4244 s->avctx->draw_horiz_band(s->avctx, src, offset,
4245 y, s->picture_structure, h);
4249 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4250 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4251 const int uvlinesize= s->current_picture.linesize[1];
4252 const int mb_size= 4 - s->avctx->lowres;
4254 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4255 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4256 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4257 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4258 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4259 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;
4260 //block_index is not used by mpeg2, so it is not affected by chroma_format
4262 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4263 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4264 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4266 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4268 s->dest[0] += s->mb_y * linesize << mb_size;
4269 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4270 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4274 #ifdef CONFIG_ENCODERS
4276 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4286 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4287 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4288 int v= ptr[x2 + y2*stride];
4294 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4299 static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4301 int16_t weight[8][64];
4302 DCTELEM orig[8][64];
4303 const int mb_x= s->mb_x;
4304 const int mb_y= s->mb_y;
4307 int dct_offset = s->linesize*8; //default for progressive frames
4308 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4311 for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4313 if(s->adaptive_quant){
4314 const int last_qp= s->qscale;
4315 const int mb_xy= mb_x + mb_y*s->mb_stride;
4317 s->lambda= s->lambda_table[mb_xy];
4320 if(!(s->flags&CODEC_FLAG_QP_RD)){
4321 s->dquant= s->qscale - last_qp;
4323 if(s->out_format==FMT_H263){
4324 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4326 if(s->codec_id==CODEC_ID_MPEG4){
4328 if(s->pict_type == B_TYPE){
4330 s->dquant= (s->dquant/2)*2;
4331 if(s->mv_dir&MV_DIRECT)
4334 if(s->mv_type==MV_TYPE_8X8)
4340 ff_set_qscale(s, last_qp + s->dquant);
4341 }else if(s->flags&CODEC_FLAG_QP_RD)
4342 ff_set_qscale(s, s->qscale + s->dquant);
4344 wrap_y = s->linesize;
4345 wrap_c = s->uvlinesize;
4346 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4347 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4348 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4350 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4351 uint8_t *ebuf= s->edge_emu_buffer + 32;
4352 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
4354 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4355 ptr_cb= ebuf+18*wrap_y;
4356 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4357 ptr_cr= ebuf+18*wrap_y+8;
4361 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4362 int progressive_score, interlaced_score;
4364 s->interlaced_dct=0;
4365 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4366 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4368 if(progressive_score > 0){
4369 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4370 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4371 if(progressive_score > interlaced_score){
4372 s->interlaced_dct=1;
4376 if (s->chroma_format == CHROMA_422)
4382 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4383 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4384 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4385 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4387 if(s->flags&CODEC_FLAG_GRAY){
4391 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4392 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4393 if(!s->chroma_y_shift){ /* 422 */
4394 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4395 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4399 op_pixels_func (*op_pix)[4];
4400 qpel_mc_func (*op_qpix)[16];
4401 uint8_t *dest_y, *dest_cb, *dest_cr;
4403 dest_y = s->dest[0];
4404 dest_cb = s->dest[1];
4405 dest_cr = s->dest[2];
4407 if ((!s->no_rounding) || s->pict_type==B_TYPE){
4408 op_pix = s->dsp.put_pixels_tab;
4409 op_qpix= s->dsp.put_qpel_pixels_tab;
4411 op_pix = s->dsp.put_no_rnd_pixels_tab;
4412 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4415 if (s->mv_dir & MV_DIR_FORWARD) {
4416 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4417 op_pix = s->dsp.avg_pixels_tab;
4418 op_qpix= s->dsp.avg_qpel_pixels_tab;
4420 if (s->mv_dir & MV_DIR_BACKWARD) {
4421 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4424 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4425 int progressive_score, interlaced_score;
4427 s->interlaced_dct=0;
4428 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4429 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4431 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4433 if(progressive_score>0){
4434 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4435 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4437 if(progressive_score > interlaced_score){
4438 s->interlaced_dct=1;
4442 if (s->chroma_format == CHROMA_422)
4448 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4449 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4450 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4451 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4453 if(s->flags&CODEC_FLAG_GRAY){
4457 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4458 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4459 if(!s->chroma_y_shift){ /* 422 */
4460 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4461 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4464 /* pre quantization */
4465 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4467 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4468 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4469 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4470 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;
4471 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4472 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4473 if(!s->chroma_y_shift){ /* 422 */
4474 if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1;
4475 if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1;
4480 if(s->avctx->quantizer_noise_shaping){
4481 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4482 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4483 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4484 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4485 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4486 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4487 if(!s->chroma_y_shift){ /* 422 */
4488 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4489 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4491 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4494 /* DCT & quantize */
4495 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4497 for(i=0;i<mb_block_count;i++) {
4500 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4501 // FIXME we could decide to change to quantizer instead of clipping
4502 // JS: I don't think that would be a good idea it could lower quality instead
4503 // of improve it. Just INTRADC clipping deserves changes in quantizer
4504 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4506 s->block_last_index[i]= -1;
4508 if(s->avctx->quantizer_noise_shaping){
4509 for(i=0;i<mb_block_count;i++) {
4511 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4516 if(s->luma_elim_threshold && !s->mb_intra)
4518 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4519 if(s->chroma_elim_threshold && !s->mb_intra)
4520 for(i=4; i<mb_block_count; i++)
4521 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4523 if(s->flags & CODEC_FLAG_CBP_RD){
4524 for(i=0;i<mb_block_count;i++) {
4525 if(s->block_last_index[i] == -1)
4526 s->coded_score[i]= INT_MAX/256;
4531 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4532 s->block_last_index[4]=
4533 s->block_last_index[5]= 0;
4535 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4538 //non c quantize code returns incorrect block_last_index FIXME
4539 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4540 for(i=0; i<mb_block_count; i++){
4542 if(s->block_last_index[i]>0){
4543 for(j=63; j>0; j--){
4544 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4546 s->block_last_index[i]= j;
4551 /* huffman encode */
4552 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4553 case CODEC_ID_MPEG1VIDEO:
4554 case CODEC_ID_MPEG2VIDEO:
4555 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4556 case CODEC_ID_MPEG4:
4557 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4558 case CODEC_ID_MSMPEG4V2:
4559 case CODEC_ID_MSMPEG4V3:
4561 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4563 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4564 #ifdef CONFIG_H261_ENCODER
4566 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4569 case CODEC_ID_H263P:
4573 h263_encode_mb(s, s->block, motion_x, motion_y); break;
4574 case CODEC_ID_MJPEG:
4575 mjpeg_encode_mb(s, s->block); break;
4581 static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4583 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
4584 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
4587 #endif //CONFIG_ENCODERS
4589 void ff_mpeg_flush(AVCodecContext *avctx){
4591 MpegEncContext *s = avctx->priv_data;
4593 if(s==NULL || s->picture==NULL)
4596 for(i=0; i<MAX_PICTURE_COUNT; i++){
4597 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4598 || s->picture[i].type == FF_BUFFER_TYPE_USER))
4599 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4601 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4603 s->mb_x= s->mb_y= 0;
4605 s->parse_context.state= -1;
4606 s->parse_context.frame_start_found= 0;
4607 s->parse_context.overread= 0;
4608 s->parse_context.overread_index= 0;
4609 s->parse_context.index= 0;
4610 s->parse_context.last_index= 0;
4611 s->bitstream_buffer_size=0;
4614 #ifdef CONFIG_ENCODERS
4615 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4617 const uint16_t *srcw= (uint16_t*)src;
4618 int words= length>>4;
4619 int bits= length&15;
4622 if(length==0) return;
4625 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4626 }else if(put_bits_count(pb)&7){
4627 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4629 for(i=0; put_bits_count(pb)&31; i++)
4630 put_bits(pb, 8, src[i]);
4632 memcpy(pbBufPtr(pb), src+i, 2*words-i);
4633 skip_put_bytes(pb, 2*words-i);
4636 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4639 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4642 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4645 d->mb_skip_run= s->mb_skip_run;
4647 d->last_dc[i]= s->last_dc[i];
4650 d->mv_bits= s->mv_bits;
4651 d->i_tex_bits= s->i_tex_bits;
4652 d->p_tex_bits= s->p_tex_bits;
4653 d->i_count= s->i_count;
4654 d->f_count= s->f_count;
4655 d->b_count= s->b_count;
4656 d->skip_count= s->skip_count;
4657 d->misc_bits= s->misc_bits;
4661 d->qscale= s->qscale;
4662 d->dquant= s->dquant;
4665 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4668 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4669 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4672 d->mb_skip_run= s->mb_skip_run;
4674 d->last_dc[i]= s->last_dc[i];
4677 d->mv_bits= s->mv_bits;
4678 d->i_tex_bits= s->i_tex_bits;
4679 d->p_tex_bits= s->p_tex_bits;
4680 d->i_count= s->i_count;
4681 d->f_count= s->f_count;
4682 d->b_count= s->b_count;
4683 d->skip_count= s->skip_count;
4684 d->misc_bits= s->misc_bits;
4686 d->mb_intra= s->mb_intra;
4687 d->mb_skipped= s->mb_skipped;
4688 d->mv_type= s->mv_type;
4689 d->mv_dir= s->mv_dir;
4691 if(s->data_partitioning){
4693 d->tex_pb= s->tex_pb;
4697 d->block_last_index[i]= s->block_last_index[i];
4698 d->interlaced_dct= s->interlaced_dct;
4699 d->qscale= s->qscale;
4702 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4703 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4704 int *dmin, int *next_block, int motion_x, int motion_y)
4707 uint8_t *dest_backup[3];
4709 copy_context_before_encode(s, backup, type);
4711 s->block= s->blocks[*next_block];
4712 s->pb= pb[*next_block];
4713 if(s->data_partitioning){
4714 s->pb2 = pb2 [*next_block];
4715 s->tex_pb= tex_pb[*next_block];
4719 memcpy(dest_backup, s->dest, sizeof(s->dest));
4720 s->dest[0] = s->rd_scratchpad;
4721 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4722 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4723 assert(s->linesize >= 32); //FIXME
4726 encode_mb(s, motion_x, motion_y);
4728 score= put_bits_count(&s->pb);
4729 if(s->data_partitioning){
4730 score+= put_bits_count(&s->pb2);
4731 score+= put_bits_count(&s->tex_pb);
4734 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4735 MPV_decode_mb(s, s->block);
4737 score *= s->lambda2;
4738 score += sse_mb(s) << FF_LAMBDA_SHIFT;
4742 memcpy(s->dest, dest_backup, sizeof(s->dest));
4749 copy_context_after_encode(best, s, type);
4753 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4754 uint32_t *sq = squareTbl + 256;
4759 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4760 else if(w==8 && h==8)
4761 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4765 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4774 static int sse_mb(MpegEncContext *s){
4778 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4779 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4782 if(s->avctx->mb_cmp == FF_CMP_NSSE){
4783 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)
4784 +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)
4785 +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);
4787 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)
4788 +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)
4789 +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);
4792 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)
4793 +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)
4794 +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);
4797 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4798 MpegEncContext *s= arg;
4802 s->me.dia_size= s->avctx->pre_dia_size;
4803 s->first_slice_line=1;
4804 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4805 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4806 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4808 s->first_slice_line=0;
4816 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4817 MpegEncContext *s= arg;
4819 s->me.dia_size= s->avctx->dia_size;
4820 s->first_slice_line=1;
4821 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4822 s->mb_x=0; //for block init below
4823 ff_init_block_index(s);
4824 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4825 s->block_index[0]+=2;
4826 s->block_index[1]+=2;
4827 s->block_index[2]+=2;
4828 s->block_index[3]+=2;
4830 /* compute motion vector & mb_type and store in context */
4831 if(s->pict_type==B_TYPE)
4832 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4834 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4836 s->first_slice_line=0;
4841 static int mb_var_thread(AVCodecContext *c, void *arg){
4842 MpegEncContext *s= arg;
4845 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4846 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4849 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4851 int sum = s->dsp.pix_sum(pix, s->linesize);
4853 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4855 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4856 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4857 s->me.mb_var_sum_temp += varc;
4863 static void write_slice_end(MpegEncContext *s){
4864 if(s->codec_id==CODEC_ID_MPEG4){
4865 if(s->partitioned_frame){
4866 ff_mpeg4_merge_partitions(s);
4869 ff_mpeg4_stuffing(&s->pb);
4870 }else if(s->out_format == FMT_MJPEG){
4871 ff_mjpeg_stuffing(&s->pb);
4874 align_put_bits(&s->pb);
4875 flush_put_bits(&s->pb);
4877 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4878 s->misc_bits+= get_bits_diff(s);
4881 static int encode_thread(AVCodecContext *c, void *arg){
4882 MpegEncContext *s= arg;
4883 int mb_x, mb_y, pdif = 0;
4885 MpegEncContext best_s, backup_s;
4886 uint8_t bit_buf[2][MAX_MB_BYTES];
4887 uint8_t bit_buf2[2][MAX_MB_BYTES];
4888 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4889 PutBitContext pb[2], pb2[2], tex_pb[2];
4890 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4893 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4894 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4895 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4898 s->last_bits= put_bits_count(&s->pb);
4909 /* init last dc values */
4910 /* note: quant matrix value (8) is implied here */
4911 s->last_dc[i] = 128 << s->intra_dc_precision;
4913 s->current_picture.error[i] = 0;
4916 memset(s->last_mv, 0, sizeof(s->last_mv));
4920 switch(s->codec_id){
4922 case CODEC_ID_H263P:
4924 s->gob_index = ff_h263_get_gob_height(s);
4926 case CODEC_ID_MPEG4:
4927 if(s->partitioned_frame)
4928 ff_mpeg4_init_partitions(s);
4934 s->first_slice_line = 1;
4935 s->ptr_lastgob = s->pb.buf;
4936 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4937 // printf("row %d at %X\n", s->mb_y, (int)s);
4941 ff_set_qscale(s, s->qscale);
4942 ff_init_block_index(s);
4944 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4945 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4946 int mb_type= s->mb_type[xy];
4951 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4952 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4955 if(s->data_partitioning){
4956 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4957 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4958 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4964 s->mb_y = mb_y; // moved into loop, can get changed by H.261
4965 ff_update_block_index(s);
4967 #ifdef CONFIG_H261_ENCODER
4968 if(s->codec_id == CODEC_ID_H261){
4969 ff_h261_reorder_mb_index(s);
4970 xy= s->mb_y*s->mb_stride + s->mb_x;
4971 mb_type= s->mb_type[xy];
4975 /* write gob / video packet header */
4977 int current_packet_size, is_gob_start;
4979 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4981 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4983 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4985 switch(s->codec_id){
4987 case CODEC_ID_H263P:
4988 if(!s->h263_slice_structured)
4989 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4991 case CODEC_ID_MPEG2VIDEO:
4992 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4993 case CODEC_ID_MPEG1VIDEO:
4994 if(s->mb_skip_run) is_gob_start=0;
4999 if(s->start_mb_y != mb_y || mb_x!=0){
5002 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
5003 ff_mpeg4_init_partitions(s);
5007 assert((put_bits_count(&s->pb)&7) == 0);
5008 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
5010 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
5011 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
5012 int d= 100 / s->avctx->error_rate;
5014 current_packet_size=0;
5015 #ifndef ALT_BITSTREAM_WRITER
5016 s->pb.buf_ptr= s->ptr_lastgob;
5018 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
5022 if (s->avctx->rtp_callback){
5023 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
5024 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
5027 switch(s->codec_id){
5028 case CODEC_ID_MPEG4:
5029 ff_mpeg4_encode_video_packet_header(s);
5030 ff_mpeg4_clean_buffers(s);
5032 case CODEC_ID_MPEG1VIDEO:
5033 case CODEC_ID_MPEG2VIDEO:
5034 ff_mpeg1_encode_slice_header(s);
5035 ff_mpeg1_clean_buffers(s);
5038 case CODEC_ID_H263P:
5039 h263_encode_gob_header(s, mb_y);
5043 if(s->flags&CODEC_FLAG_PASS1){
5044 int bits= put_bits_count(&s->pb);
5045 s->misc_bits+= bits - s->last_bits;
5049 s->ptr_lastgob += current_packet_size;
5050 s->first_slice_line=1;
5051 s->resync_mb_x=mb_x;
5052 s->resync_mb_y=mb_y;
5056 if( (s->resync_mb_x == s->mb_x)
5057 && s->resync_mb_y+1 == s->mb_y){
5058 s->first_slice_line=0;
5062 s->dquant=0; //only for QP_RD
5064 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5066 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5068 copy_context_before_encode(&backup_s, s, -1);
5070 best_s.data_partitioning= s->data_partitioning;
5071 best_s.partitioned_frame= s->partitioned_frame;
5072 if(s->data_partitioning){
5073 backup_s.pb2= s->pb2;
5074 backup_s.tex_pb= s->tex_pb;
5077 if(mb_type&CANDIDATE_MB_TYPE_INTER){
5078 s->mv_dir = MV_DIR_FORWARD;
5079 s->mv_type = MV_TYPE_16X16;
5081 s->mv[0][0][0] = s->p_mv_table[xy][0];
5082 s->mv[0][0][1] = s->p_mv_table[xy][1];
5083 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5084 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5086 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5087 s->mv_dir = MV_DIR_FORWARD;
5088 s->mv_type = MV_TYPE_FIELD;
5091 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5092 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5093 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5095 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5096 &dmin, &next_block, 0, 0);
5098 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5099 s->mv_dir = MV_DIR_FORWARD;
5100 s->mv_type = MV_TYPE_16X16;
5104 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5105 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5107 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5108 s->mv_dir = MV_DIR_FORWARD;
5109 s->mv_type = MV_TYPE_8X8;
5112 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5113 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5115 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5116 &dmin, &next_block, 0, 0);
5118 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5119 s->mv_dir = MV_DIR_FORWARD;
5120 s->mv_type = MV_TYPE_16X16;
5122 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5123 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5124 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5125 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5127 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5128 s->mv_dir = MV_DIR_BACKWARD;
5129 s->mv_type = MV_TYPE_16X16;
5131 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5132 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5133 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5134 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5136 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5137 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5138 s->mv_type = MV_TYPE_16X16;
5140 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5141 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5142 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5143 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5144 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5145 &dmin, &next_block, 0, 0);
5147 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5148 int mx= s->b_direct_mv_table[xy][0];
5149 int my= s->b_direct_mv_table[xy][1];
5151 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5153 ff_mpeg4_set_direct_mv(s, mx, my);
5154 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5155 &dmin, &next_block, mx, my);
5157 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5158 s->mv_dir = MV_DIR_FORWARD;
5159 s->mv_type = MV_TYPE_FIELD;
5162 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5163 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5164 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5166 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5167 &dmin, &next_block, 0, 0);
5169 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5170 s->mv_dir = MV_DIR_BACKWARD;
5171 s->mv_type = MV_TYPE_FIELD;
5174 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5175 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5176 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5178 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5179 &dmin, &next_block, 0, 0);
5181 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5182 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5183 s->mv_type = MV_TYPE_FIELD;
5185 for(dir=0; dir<2; dir++){
5187 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5188 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5189 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5192 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5193 &dmin, &next_block, 0, 0);
5195 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5197 s->mv_type = MV_TYPE_16X16;
5201 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5202 &dmin, &next_block, 0, 0);
5203 if(s->h263_pred || s->h263_aic){
5205 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5207 ff_clean_intra_table_entries(s); //old mode?
5211 if(s->flags & CODEC_FLAG_QP_RD){
5212 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
5213 const int last_qp= backup_s.qscale;
5214 int dquant, dir, qp, dc[6];
5216 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5218 assert(backup_s.dquant == 0);
5221 s->mv_dir= best_s.mv_dir;
5222 s->mv_type = MV_TYPE_16X16;
5223 s->mb_intra= best_s.mb_intra;
5224 s->mv[0][0][0] = best_s.mv[0][0][0];
5225 s->mv[0][0][1] = best_s.mv[0][0][1];
5226 s->mv[1][0][0] = best_s.mv[1][0][0];
5227 s->mv[1][0][1] = best_s.mv[1][0][1];
5229 dir= s->pict_type == B_TYPE ? 2 : 1;
5230 if(last_qp + dir > s->avctx->qmax) dir= -dir;
5231 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
5232 qp= last_qp + dquant;
5233 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5235 backup_s.dquant= dquant;
5236 if(s->mb_intra && s->dc_val[0]){
5238 dc[i]= s->dc_val[0][ s->block_index[i] ];
5239 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5243 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5244 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5245 if(best_s.qscale != qp){
5246 if(s->mb_intra && s->dc_val[0]){
5248 s->dc_val[0][ s->block_index[i] ]= dc[i];
5249 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5252 if(dir > 0 && dquant==dir){
5260 s->current_picture.qscale_table[xy]= qp;
5264 copy_context_after_encode(s, &best_s, -1);
5266 pb_bits_count= put_bits_count(&s->pb);
5267 flush_put_bits(&s->pb);
5268 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5271 if(s->data_partitioning){
5272 pb2_bits_count= put_bits_count(&s->pb2);
5273 flush_put_bits(&s->pb2);
5274 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5275 s->pb2= backup_s.pb2;
5277 tex_pb_bits_count= put_bits_count(&s->tex_pb);
5278 flush_put_bits(&s->tex_pb);
5279 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5280 s->tex_pb= backup_s.tex_pb;
5282 s->last_bits= put_bits_count(&s->pb);
5284 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5285 ff_h263_update_motion_val(s);
5287 if(next_block==0){ //FIXME 16 vs linesize16
5288 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5289 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5290 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5293 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5294 MPV_decode_mb(s, s->block);
5296 int motion_x, motion_y;
5297 s->mv_type=MV_TYPE_16X16;
5298 // only one MB-Type possible
5301 case CANDIDATE_MB_TYPE_INTRA:
5304 motion_x= s->mv[0][0][0] = 0;
5305 motion_y= s->mv[0][0][1] = 0;
5307 case CANDIDATE_MB_TYPE_INTER:
5308 s->mv_dir = MV_DIR_FORWARD;
5310 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5311 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5313 case CANDIDATE_MB_TYPE_INTER_I:
5314 s->mv_dir = MV_DIR_FORWARD;
5315 s->mv_type = MV_TYPE_FIELD;
5318 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5319 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5320 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5322 motion_x = motion_y = 0;
5324 case CANDIDATE_MB_TYPE_INTER4V:
5325 s->mv_dir = MV_DIR_FORWARD;
5326 s->mv_type = MV_TYPE_8X8;
5329 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5330 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5332 motion_x= motion_y= 0;
5334 case CANDIDATE_MB_TYPE_DIRECT:
5335 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5337 motion_x=s->b_direct_mv_table[xy][0];
5338 motion_y=s->b_direct_mv_table[xy][1];
5339 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5341 case CANDIDATE_MB_TYPE_BIDIR:
5342 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5346 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5347 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5348 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5349 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5351 case CANDIDATE_MB_TYPE_BACKWARD:
5352 s->mv_dir = MV_DIR_BACKWARD;
5354 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5355 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5357 case CANDIDATE_MB_TYPE_FORWARD:
5358 s->mv_dir = MV_DIR_FORWARD;
5360 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5361 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5362 // printf(" %d %d ", motion_x, motion_y);
5364 case CANDIDATE_MB_TYPE_FORWARD_I:
5365 s->mv_dir = MV_DIR_FORWARD;
5366 s->mv_type = MV_TYPE_FIELD;
5369 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5370 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5371 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5373 motion_x=motion_y=0;
5375 case CANDIDATE_MB_TYPE_BACKWARD_I:
5376 s->mv_dir = MV_DIR_BACKWARD;
5377 s->mv_type = MV_TYPE_FIELD;
5380 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5381 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5382 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5384 motion_x=motion_y=0;
5386 case CANDIDATE_MB_TYPE_BIDIR_I:
5387 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5388 s->mv_type = MV_TYPE_FIELD;
5390 for(dir=0; dir<2; dir++){
5392 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5393 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5394 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5397 motion_x=motion_y=0;
5400 motion_x=motion_y=0; //gcc warning fix
5401 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5404 encode_mb(s, motion_x, motion_y);
5406 // RAL: Update last macroblock type
5407 s->last_mv_dir = s->mv_dir;
5409 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5410 ff_h263_update_motion_val(s);
5412 MPV_decode_mb(s, s->block);
5415 /* clean the MV table in IPS frames for direct mode in B frames */
5416 if(s->mb_intra /* && I,P,S_TYPE */){
5417 s->p_mv_table[xy][0]=0;
5418 s->p_mv_table[xy][1]=0;
5421 if(s->flags&CODEC_FLAG_PSNR){
5425 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
5426 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
5428 s->current_picture.error[0] += sse(
5429 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
5430 s->dest[0], w, h, s->linesize);
5431 s->current_picture.error[1] += sse(
5432 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5433 s->dest[1], w>>1, h>>1, s->uvlinesize);
5434 s->current_picture.error[2] += sse(
5435 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5436 s->dest[2], w>>1, h>>1, s->uvlinesize);
5439 if(s->out_format == FMT_H263)
5440 ff_h263_loop_filter(s);
5442 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5446 //not beautiful here but we must write it before flushing so it has to be here
5447 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5448 msmpeg4_encode_ext_header(s);
5452 /* Send the last GOB if RTP */
5453 if (s->avctx->rtp_callback) {
5454 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5455 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5456 /* Call the RTP callback to send the last GOB */
5458 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5464 #define MERGE(field) dst->field += src->field; src->field=0
5465 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5466 MERGE(me.scene_change_score);
5467 MERGE(me.mc_mb_var_sum_temp);
5468 MERGE(me.mb_var_sum_temp);
5471 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
5474 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5475 MERGE(dct_count[1]);
5485 MERGE(padding_bug_score);
5486 MERGE(current_picture.error[0]);
5487 MERGE(current_picture.error[1]);
5488 MERGE(current_picture.error[2]);
5490 if(dst->avctx->noise_reduction){
5491 for(i=0; i<64; i++){
5492 MERGE(dct_error_sum[0][i]);
5493 MERGE(dct_error_sum[1][i]);
5497 assert(put_bits_count(&src->pb) % 8 ==0);
5498 assert(put_bits_count(&dst->pb) % 8 ==0);
5499 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5500 flush_put_bits(&dst->pb);
5503 static int estimate_qp(MpegEncContext *s, int dry_run){
5504 if (s->next_lambda){
5505 s->current_picture_ptr->quality=
5506 s->current_picture.quality = s->next_lambda;
5507 if(!dry_run) s->next_lambda= 0;
5508 } else if (!s->fixed_qscale) {
5509 s->current_picture_ptr->quality=
5510 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5511 if (s->current_picture.quality < 0)
5515 if(s->adaptive_quant){
5516 switch(s->codec_id){
5517 case CODEC_ID_MPEG4:
5518 ff_clean_mpeg4_qscales(s);
5521 case CODEC_ID_H263P:
5523 ff_clean_h263_qscales(s);
5527 s->lambda= s->lambda_table[0];
5530 s->lambda= s->current_picture.quality;
5531 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5536 static int encode_picture(MpegEncContext *s, int picture_number)
5541 s->picture_number = picture_number;
5543 /* Reset the average MB variance */
5544 s->me.mb_var_sum_temp =
5545 s->me.mc_mb_var_sum_temp = 0;
5547 /* we need to initialize some time vars before we can encode b-frames */
5548 // RAL: Condition added for MPEG1VIDEO
5549 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5550 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5552 s->me.scene_change_score=0;
5554 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5556 if(s->pict_type==I_TYPE){
5557 if(s->msmpeg4_version >= 3) s->no_rounding=1;
5558 else s->no_rounding=0;
5559 }else if(s->pict_type!=B_TYPE){
5560 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5561 s->no_rounding ^= 1;
5564 if(s->flags & CODEC_FLAG_PASS2){
5565 if (estimate_qp(s,1) < 0)
5567 ff_get_2pass_fcode(s);
5568 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5569 if(s->pict_type==B_TYPE)
5570 s->lambda= s->last_lambda_for[s->pict_type];
5572 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5576 s->mb_intra=0; //for the rate distortion & bit compare functions
5577 for(i=1; i<s->avctx->thread_count; i++){
5578 ff_update_duplicate_context(s->thread_context[i], s);
5583 /* Estimate motion for every MB */
5584 if(s->pict_type != I_TYPE){
5585 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5586 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
5587 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5588 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
5589 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5593 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5594 }else /* if(s->pict_type == I_TYPE) */{
5596 for(i=0; i<s->mb_stride*s->mb_height; i++)
5597 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5599 if(!s->fixed_qscale){
5600 /* finding spatial complexity for I-frame rate control */
5601 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5604 for(i=1; i<s->avctx->thread_count; i++){
5605 merge_context_after_me(s, s->thread_context[i]);
5607 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5608 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5611 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5612 s->pict_type= I_TYPE;
5613 for(i=0; i<s->mb_stride*s->mb_height; i++)
5614 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5615 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5619 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5620 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5622 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5624 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5625 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5626 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5629 ff_fix_long_p_mvs(s);
5630 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5631 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5635 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5636 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5641 if(s->pict_type==B_TYPE){
5644 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5645 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5646 s->f_code = FFMAX(a, b);
5648 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5649 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5650 s->b_code = FFMAX(a, b);
5652 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5653 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5654 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5655 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5656 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5658 for(dir=0; dir<2; dir++){
5661 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5662 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5663 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5664 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5672 if (estimate_qp(s, 0) < 0)
5675 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5676 s->qscale= 3; //reduce clipping problems
5678 if (s->out_format == FMT_MJPEG) {
5679 /* for mjpeg, we do include qscale in the matrix */
5680 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5682 int j= s->dsp.idct_permutation[i];
5684 s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5686 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5687 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5691 //FIXME var duplication
5692 s->current_picture_ptr->key_frame=
5693 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5694 s->current_picture_ptr->pict_type=
5695 s->current_picture.pict_type= s->pict_type;
5697 if(s->current_picture.key_frame)
5698 s->picture_in_gop_number=0;
5700 s->last_bits= put_bits_count(&s->pb);
5701 switch(s->out_format) {
5703 mjpeg_picture_header(s);
5705 #ifdef CONFIG_H261_ENCODER
5707 ff_h261_encode_picture_header(s, picture_number);
5711 if (s->codec_id == CODEC_ID_WMV2)
5712 ff_wmv2_encode_picture_header(s, picture_number);
5713 else if (s->h263_msmpeg4)
5714 msmpeg4_encode_picture_header(s, picture_number);
5715 else if (s->h263_pred)
5716 mpeg4_encode_picture_header(s, picture_number);
5717 #ifdef CONFIG_RV10_ENCODER
5718 else if (s->codec_id == CODEC_ID_RV10)
5719 rv10_encode_picture_header(s, picture_number);
5721 #ifdef CONFIG_RV20_ENCODER
5722 else if (s->codec_id == CODEC_ID_RV20)
5723 rv20_encode_picture_header(s, picture_number);
5725 else if (s->codec_id == CODEC_ID_FLV1)
5726 ff_flv_encode_picture_header(s, picture_number);
5728 h263_encode_picture_header(s, picture_number);
5731 mpeg1_encode_picture_header(s, picture_number);
5738 bits= put_bits_count(&s->pb);
5739 s->header_bits= bits - s->last_bits;
5741 for(i=1; i<s->avctx->thread_count; i++){
5742 update_duplicate_context_after_me(s->thread_context[i], s);
5744 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5745 for(i=1; i<s->avctx->thread_count; i++){
5746 merge_context_after_encode(s, s->thread_context[i]);
5752 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5753 const int intra= s->mb_intra;
5756 s->dct_count[intra]++;
5758 for(i=0; i<64; i++){
5759 int level= block[i];
5763 s->dct_error_sum[intra][i] += level;
5764 level -= s->dct_offset[intra][i];
5765 if(level<0) level=0;
5767 s->dct_error_sum[intra][i] -= level;
5768 level += s->dct_offset[intra][i];
5769 if(level>0) level=0;
5776 static int dct_quantize_trellis_c(MpegEncContext *s,
5777 DCTELEM *block, int n,
5778 int qscale, int *overflow){
5780 const uint8_t *scantable= s->intra_scantable.scantable;
5781 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5783 unsigned int threshold1, threshold2;
5795 int coeff_count[64];
5796 int qmul, qadd, start_i, last_non_zero, i, dc;
5797 const int esc_length= s->ac_esc_length;
5799 uint8_t * last_length;
5800 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5802 s->dsp.fdct (block);
5804 if(s->dct_error_sum)
5805 s->denoise_dct(s, block);
5807 qadd= ((qscale-1)|1)*8;
5818 /* For AIC we skip quant/dequant of INTRADC */
5823 /* note: block[0] is assumed to be positive */
5824 block[0] = (block[0] + (q >> 1)) / q;
5827 qmat = s->q_intra_matrix[qscale];
5828 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5829 bias= 1<<(QMAT_SHIFT-1);
5830 length = s->intra_ac_vlc_length;
5831 last_length= s->intra_ac_vlc_last_length;
5835 qmat = s->q_inter_matrix[qscale];
5836 length = s->inter_ac_vlc_length;
5837 last_length= s->inter_ac_vlc_last_length;
5841 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5842 threshold2= (threshold1<<1);
5844 for(i=63; i>=start_i; i--) {
5845 const int j = scantable[i];
5846 int level = block[j] * qmat[j];
5848 if(((unsigned)(level+threshold1))>threshold2){
5854 for(i=start_i; i<=last_non_zero; i++) {
5855 const int j = scantable[i];
5856 int level = block[j] * qmat[j];
5858 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
5859 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
5860 if(((unsigned)(level+threshold1))>threshold2){
5862 level= (bias + level)>>QMAT_SHIFT;
5864 coeff[1][i]= level-1;
5865 // coeff[2][k]= level-2;
5867 level= (bias - level)>>QMAT_SHIFT;
5868 coeff[0][i]= -level;
5869 coeff[1][i]= -level+1;
5870 // coeff[2][k]= -level+2;
5872 coeff_count[i]= FFMIN(level, 2);
5873 assert(coeff_count[i]);
5876 coeff[0][i]= (level>>31)|1;
5881 *overflow= s->max_qcoeff < max; //overflow might have happened
5883 if(last_non_zero < start_i){
5884 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5885 return last_non_zero;
5888 score_tab[start_i]= 0;
5889 survivor[0]= start_i;
5892 for(i=start_i; i<=last_non_zero; i++){
5894 const int dct_coeff= FFABS(block[ scantable[i] ]);
5895 const int zero_distoration= dct_coeff*dct_coeff;
5896 int best_score=256*256*256*120;
5897 for(level_index=0; level_index < coeff_count[i]; level_index++){
5899 int level= coeff[level_index][i];
5900 const int alevel= FFABS(level);
5905 if(s->out_format == FMT_H263){
5906 unquant_coeff= alevel*qmul + qadd;
5908 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5910 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5911 unquant_coeff = (unquant_coeff - 1) | 1;
5913 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5914 unquant_coeff = (unquant_coeff - 1) | 1;
5919 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5921 if((level&(~127)) == 0){
5922 for(j=survivor_count-1; j>=0; j--){
5923 int run= i - survivor[j];
5924 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5925 score += score_tab[i-run];
5927 if(score < best_score){
5930 level_tab[i+1]= level-64;
5934 if(s->out_format == FMT_H263){
5935 for(j=survivor_count-1; j>=0; j--){
5936 int run= i - survivor[j];
5937 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5938 score += score_tab[i-run];
5939 if(score < last_score){
5942 last_level= level-64;
5948 distoration += esc_length*lambda;
5949 for(j=survivor_count-1; j>=0; j--){
5950 int run= i - survivor[j];
5951 int score= distoration + score_tab[i-run];
5953 if(score < best_score){
5956 level_tab[i+1]= level-64;
5960 if(s->out_format == FMT_H263){
5961 for(j=survivor_count-1; j>=0; j--){
5962 int run= i - survivor[j];
5963 int score= distoration + score_tab[i-run];
5964 if(score < last_score){
5967 last_level= level-64;
5975 score_tab[i+1]= best_score;
5977 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5978 if(last_non_zero <= 27){
5979 for(; survivor_count; survivor_count--){
5980 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5984 for(; survivor_count; survivor_count--){
5985 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5990 survivor[ survivor_count++ ]= i+1;
5993 if(s->out_format != FMT_H263){
5994 last_score= 256*256*256*120;
5995 for(i= survivor[0]; i<=last_non_zero + 1; i++){
5996 int score= score_tab[i];
5997 if(i) score += lambda*2; //FIXME exacter?
5999 if(score < last_score){
6002 last_level= level_tab[i];
6003 last_run= run_tab[i];
6008 s->coded_score[n] = last_score;
6010 dc= FFABS(block[0]);
6011 last_non_zero= last_i - 1;
6012 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
6014 if(last_non_zero < start_i)
6015 return last_non_zero;
6017 if(last_non_zero == 0 && start_i == 0){
6019 int best_score= dc * dc;
6021 for(i=0; i<coeff_count[0]; i++){
6022 int level= coeff[i][0];
6023 int alevel= FFABS(level);
6024 int unquant_coeff, score, distortion;
6026 if(s->out_format == FMT_H263){
6027 unquant_coeff= (alevel*qmul + qadd)>>3;
6029 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
6030 unquant_coeff = (unquant_coeff - 1) | 1;
6032 unquant_coeff = (unquant_coeff + 4) >> 3;
6033 unquant_coeff<<= 3 + 3;
6035 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
6037 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
6038 else score= distortion + esc_length*lambda;
6040 if(score < best_score){
6042 best_level= level - 64;
6045 block[0]= best_level;
6046 s->coded_score[n] = best_score - dc*dc;
6047 if(best_level == 0) return -1;
6048 else return last_non_zero;
6054 block[ perm_scantable[last_non_zero] ]= last_level;
6057 for(; i>start_i; i -= run_tab[i] + 1){
6058 block[ perm_scantable[i-1] ]= level_tab[i];
6061 return last_non_zero;
6064 //#define REFINE_STATS 1
6065 static int16_t basis[64][64];
6067 static void build_basis(uint8_t *perm){
6074 double s= 0.25*(1<<BASIS_SHIFT);
6076 int perm_index= perm[index];
6077 if(i==0) s*= sqrt(0.5);
6078 if(j==0) s*= sqrt(0.5);
6079 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)));
6086 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
6087 DCTELEM *block, int16_t *weight, DCTELEM *orig,
6090 DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6092 const uint8_t *scantable= s->intra_scantable.scantable;
6093 const uint8_t *perm_scantable= s->intra_scantable.permutated;
6094 // unsigned int threshold1, threshold2;
6099 int qmul, qadd, start_i, last_non_zero, i, dc;
6101 uint8_t * last_length;
6103 int rle_index, run, q, sum;
6106 static int after_last=0;
6107 static int to_zero=0;
6108 static int from_zero=0;
6111 static int messed_sign=0;
6114 if(basis[0][0] == 0)
6115 build_basis(s->dsp.idct_permutation);
6126 /* For AIC we skip quant/dequant of INTRADC */
6130 q <<= RECON_SHIFT-3;
6131 /* note: block[0] is assumed to be positive */
6133 // block[0] = (block[0] + (q >> 1)) / q;
6135 qmat = s->q_intra_matrix[qscale];
6136 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
6137 // bias= 1<<(QMAT_SHIFT-1);
6138 length = s->intra_ac_vlc_length;
6139 last_length= s->intra_ac_vlc_last_length;
6143 qmat = s->q_inter_matrix[qscale];
6144 length = s->inter_ac_vlc_length;
6145 last_length= s->inter_ac_vlc_last_length;
6147 last_non_zero = s->block_last_index[n];
6152 dc += (1<<(RECON_SHIFT-1));
6153 for(i=0; i<64; i++){
6154 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6157 STOP_TIMER("memset rem[]")}
6160 for(i=0; i<64; i++){
6165 w= FFABS(weight[i]) + qns*one;
6166 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
6169 // w=weight[i] = (63*qns + (w/2)) / w;
6175 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6181 for(i=start_i; i<=last_non_zero; i++){
6182 int j= perm_scantable[i];
6183 const int level= block[j];
6187 if(level<0) coeff= qmul*level - qadd;
6188 else coeff= qmul*level + qadd;
6189 run_tab[rle_index++]=run;
6192 s->dsp.add_8x8basis(rem, basis[j], coeff);
6198 if(last_non_zero>0){
6199 STOP_TIMER("init rem[]")
6206 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6209 int run2, best_unquant_change=0, analyze_gradient;
6213 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
6215 if(analyze_gradient){
6219 for(i=0; i<64; i++){
6222 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6225 STOP_TIMER("rem*w*w")}
6235 const int level= block[0];
6236 int change, old_coeff;
6238 assert(s->mb_intra);
6242 for(change=-1; change<=1; change+=2){
6243 int new_level= level + change;
6244 int score, new_coeff;
6246 new_coeff= q*new_level;
6247 if(new_coeff >= 2048 || new_coeff < 0)
6250 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6251 if(score<best_score){
6254 best_change= change;
6255 best_unquant_change= new_coeff - old_coeff;
6262 run2= run_tab[rle_index++];
6266 for(i=start_i; i<64; i++){
6267 int j= perm_scantable[i];
6268 const int level= block[j];
6269 int change, old_coeff;
6271 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6275 if(level<0) old_coeff= qmul*level - qadd;
6276 else old_coeff= qmul*level + qadd;
6277 run2= run_tab[rle_index++]; //FIXME ! maybe after last
6281 assert(run2>=0 || i >= last_non_zero );
6284 for(change=-1; change<=1; change+=2){
6285 int new_level= level + change;
6286 int score, new_coeff, unquant_change;
6289 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
6293 if(new_level<0) new_coeff= qmul*new_level - qadd;
6294 else new_coeff= qmul*new_level + qadd;
6295 if(new_coeff >= 2048 || new_coeff <= -2048)
6297 //FIXME check for overflow
6300 if(level < 63 && level > -63){
6301 if(i < last_non_zero)
6302 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6303 - length[UNI_AC_ENC_INDEX(run, level+64)];
6305 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6306 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
6309 assert(FFABS(new_level)==1);
6311 if(analyze_gradient){
6312 int g= d1[ scantable[i] ];
6313 if(g && (g^new_level) >= 0)
6317 if(i < last_non_zero){
6318 int next_i= i + run2 + 1;
6319 int next_level= block[ perm_scantable[next_i] ] + 64;
6321 if(next_level&(~127))
6324 if(next_i < last_non_zero)
6325 score += length[UNI_AC_ENC_INDEX(run, 65)]
6326 + length[UNI_AC_ENC_INDEX(run2, next_level)]
6327 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6329 score += length[UNI_AC_ENC_INDEX(run, 65)]
6330 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6331 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6333 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6335 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6336 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6342 assert(FFABS(level)==1);
6344 if(i < last_non_zero){
6345 int next_i= i + run2 + 1;
6346 int next_level= block[ perm_scantable[next_i] ] + 64;
6348 if(next_level&(~127))
6351 if(next_i < last_non_zero)
6352 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6353 - length[UNI_AC_ENC_INDEX(run2, next_level)]
6354 - length[UNI_AC_ENC_INDEX(run, 65)];
6356 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6357 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6358 - length[UNI_AC_ENC_INDEX(run, 65)];
6360 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6362 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6363 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6370 unquant_change= new_coeff - old_coeff;
6371 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6373 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6374 if(score<best_score){
6377 best_change= change;
6378 best_unquant_change= unquant_change;
6382 prev_level= level + 64;
6383 if(prev_level&(~127))
6392 STOP_TIMER("iterative step")}
6396 int j= perm_scantable[ best_coeff ];
6398 block[j] += best_change;
6400 if(best_coeff > last_non_zero){
6401 last_non_zero= best_coeff;
6409 if(block[j] - best_change){
6410 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
6422 for(; last_non_zero>=start_i; last_non_zero--){
6423 if(block[perm_scantable[last_non_zero]])
6429 if(256*256*256*64 % count == 0){
6430 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);
6435 for(i=start_i; i<=last_non_zero; i++){
6436 int j= perm_scantable[i];
6437 const int level= block[j];
6440 run_tab[rle_index++]=run;
6447 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6453 if(last_non_zero>0){
6454 STOP_TIMER("iterative search")
6459 return last_non_zero;
6462 static int dct_quantize_c(MpegEncContext *s,
6463 DCTELEM *block, int n,
6464 int qscale, int *overflow)
6466 int i, j, level, last_non_zero, q, start_i;
6468 const uint8_t *scantable= s->intra_scantable.scantable;
6471 unsigned int threshold1, threshold2;
6473 s->dsp.fdct (block);
6475 if(s->dct_error_sum)
6476 s->denoise_dct(s, block);
6486 /* For AIC we skip quant/dequant of INTRADC */
6489 /* note: block[0] is assumed to be positive */
6490 block[0] = (block[0] + (q >> 1)) / q;
6493 qmat = s->q_intra_matrix[qscale];
6494 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6498 qmat = s->q_inter_matrix[qscale];
6499 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6501 threshold1= (1<<QMAT_SHIFT) - bias - 1;
6502 threshold2= (threshold1<<1);
6503 for(i=63;i>=start_i;i--) {
6505 level = block[j] * qmat[j];
6507 if(((unsigned)(level+threshold1))>threshold2){
6514 for(i=start_i; i<=last_non_zero; i++) {
6516 level = block[j] * qmat[j];
6518 // if( bias+level >= (1<<QMAT_SHIFT)
6519 // || bias-level >= (1<<QMAT_SHIFT)){
6520 if(((unsigned)(level+threshold1))>threshold2){
6522 level= (bias + level)>>QMAT_SHIFT;
6525 level= (bias - level)>>QMAT_SHIFT;
6533 *overflow= s->max_qcoeff < max; //overflow might have happened
6535 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6536 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6537 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6539 return last_non_zero;
6542 #endif //CONFIG_ENCODERS
6544 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6545 DCTELEM *block, int n, int qscale)
6547 int i, level, nCoeffs;
6548 const uint16_t *quant_matrix;
6550 nCoeffs= s->block_last_index[n];
6553 block[0] = block[0] * s->y_dc_scale;
6555 block[0] = block[0] * s->c_dc_scale;
6556 /* XXX: only mpeg1 */
6557 quant_matrix = s->intra_matrix;
6558 for(i=1;i<=nCoeffs;i++) {
6559 int j= s->intra_scantable.permutated[i];
6564 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6565 level = (level - 1) | 1;
6568 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6569 level = (level - 1) | 1;
6576 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6577 DCTELEM *block, int n, int qscale)
6579 int i, level, nCoeffs;
6580 const uint16_t *quant_matrix;
6582 nCoeffs= s->block_last_index[n];
6584 quant_matrix = s->inter_matrix;
6585 for(i=0; i<=nCoeffs; i++) {
6586 int j= s->intra_scantable.permutated[i];
6591 level = (((level << 1) + 1) * qscale *
6592 ((int) (quant_matrix[j]))) >> 4;
6593 level = (level - 1) | 1;
6596 level = (((level << 1) + 1) * qscale *
6597 ((int) (quant_matrix[j]))) >> 4;
6598 level = (level - 1) | 1;
6605 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6606 DCTELEM *block, int n, int qscale)
6608 int i, level, nCoeffs;
6609 const uint16_t *quant_matrix;
6611 if(s->alternate_scan) nCoeffs= 63;
6612 else nCoeffs= s->block_last_index[n];
6615 block[0] = block[0] * s->y_dc_scale;
6617 block[0] = block[0] * s->c_dc_scale;
6618 quant_matrix = s->intra_matrix;
6619 for(i=1;i<=nCoeffs;i++) {
6620 int j= s->intra_scantable.permutated[i];
6625 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6628 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6635 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
6636 DCTELEM *block, int n, int qscale)
6638 int i, level, nCoeffs;
6639 const uint16_t *quant_matrix;
6642 if(s->alternate_scan) nCoeffs= 63;
6643 else nCoeffs= s->block_last_index[n];
6646 block[0] = block[0] * s->y_dc_scale;
6648 block[0] = block[0] * s->c_dc_scale;
6649 quant_matrix = s->intra_matrix;
6650 for(i=1;i<=nCoeffs;i++) {
6651 int j= s->intra_scantable.permutated[i];
6656 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6659 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6668 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6669 DCTELEM *block, int n, int qscale)
6671 int i, level, nCoeffs;
6672 const uint16_t *quant_matrix;
6675 if(s->alternate_scan) nCoeffs= 63;
6676 else nCoeffs= s->block_last_index[n];
6678 quant_matrix = s->inter_matrix;
6679 for(i=0; i<=nCoeffs; i++) {
6680 int j= s->intra_scantable.permutated[i];
6685 level = (((level << 1) + 1) * qscale *
6686 ((int) (quant_matrix[j]))) >> 4;
6689 level = (((level << 1) + 1) * qscale *
6690 ((int) (quant_matrix[j]))) >> 4;
6699 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6700 DCTELEM *block, int n, int qscale)
6702 int i, level, qmul, qadd;
6705 assert(s->block_last_index[n]>=0);
6711 block[0] = block[0] * s->y_dc_scale;
6713 block[0] = block[0] * s->c_dc_scale;
6714 qadd = (qscale - 1) | 1;
6721 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6723 for(i=1; i<=nCoeffs; i++) {
6727 level = level * qmul - qadd;
6729 level = level * qmul + qadd;
6736 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6737 DCTELEM *block, int n, int qscale)
6739 int i, level, qmul, qadd;
6742 assert(s->block_last_index[n]>=0);
6744 qadd = (qscale - 1) | 1;
6747 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6749 for(i=0; i<=nCoeffs; i++) {
6753 level = level * qmul - qadd;
6755 level = level * qmul + qadd;
6762 #ifdef CONFIG_ENCODERS
6763 AVCodec h263_encoder = {
6767 sizeof(MpegEncContext),
6771 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6774 AVCodec h263p_encoder = {
6778 sizeof(MpegEncContext),
6782 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6785 AVCodec flv_encoder = {
6789 sizeof(MpegEncContext),
6793 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6796 AVCodec rv10_encoder = {
6800 sizeof(MpegEncContext),
6804 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6807 AVCodec rv20_encoder = {
6811 sizeof(MpegEncContext),
6815 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6818 AVCodec mpeg4_encoder = {
6822 sizeof(MpegEncContext),
6826 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6827 .capabilities= CODEC_CAP_DELAY,
6830 AVCodec msmpeg4v1_encoder = {
6834 sizeof(MpegEncContext),
6838 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6841 AVCodec msmpeg4v2_encoder = {
6845 sizeof(MpegEncContext),
6849 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6852 AVCodec msmpeg4v3_encoder = {
6856 sizeof(MpegEncContext),
6860 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6863 AVCodec wmv1_encoder = {
6867 sizeof(MpegEncContext),
6871 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6874 AVCodec mjpeg_encoder = {
6878 sizeof(MpegEncContext),
6882 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1},
6885 #endif //CONFIG_ENCODERS