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_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_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_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 than %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= av_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->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->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, set threshold to 1000000000\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->flags & CODEC_FLAG_LOW_DELAY){
1108 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1109 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1112 if (s->max_b_frames != 0){
1113 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1118 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1119 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1120 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1121 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1125 if(s->avctx->thread_count > 1)
1128 if(!avctx->time_base.den || !avctx->time_base.num){
1129 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1133 i= (INT_MAX/2+128)>>8;
1134 if(avctx->me_threshold >= i){
1135 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1138 if(avctx->mb_threshold >= i){
1139 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1143 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1144 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1145 avctx->b_frame_strategy = 0;
1148 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1150 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1151 avctx->time_base.den /= i;
1152 avctx->time_base.num /= i;
1156 if(s->codec_id==CODEC_ID_MJPEG){
1157 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1158 s->inter_quant_bias= 0;
1159 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1160 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1161 s->inter_quant_bias= 0;
1163 s->intra_quant_bias=0;
1164 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1167 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1168 s->intra_quant_bias= avctx->intra_quant_bias;
1169 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1170 s->inter_quant_bias= avctx->inter_quant_bias;
1172 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1174 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1175 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1178 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1180 switch(avctx->codec->id) {
1181 case CODEC_ID_MPEG1VIDEO:
1182 s->out_format = FMT_MPEG1;
1183 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1184 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1186 case CODEC_ID_MPEG2VIDEO:
1187 s->out_format = FMT_MPEG1;
1188 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1189 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1192 case CODEC_ID_LJPEG:
1193 case CODEC_ID_JPEGLS:
1194 case CODEC_ID_MJPEG:
1195 s->out_format = FMT_MJPEG;
1196 s->intra_only = 1; /* force intra only for jpeg */
1197 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1198 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1199 s->mjpeg_vsample[0] = 2;
1200 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1201 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1202 s->mjpeg_hsample[0] = 2;
1203 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1204 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1205 if (mjpeg_init(s) < 0)
1210 #ifdef CONFIG_H261_ENCODER
1212 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1213 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
1216 s->out_format = FMT_H261;
1222 if (h263_get_picture_format(s->width, s->height) == 7) {
1223 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);
1226 s->out_format = FMT_H263;
1227 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1231 case CODEC_ID_H263P:
1232 s->out_format = FMT_H263;
1235 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1236 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1237 s->modified_quant= s->h263_aic;
1238 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1239 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1240 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1241 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1242 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1245 /* These are just to be sure */
1250 s->out_format = FMT_H263;
1251 s->h263_flv = 2; /* format = 1; 11-bit codes */
1252 s->unrestricted_mv = 1;
1253 s->rtp_mode=0; /* don't allow GOB */
1258 s->out_format = FMT_H263;
1263 s->out_format = FMT_H263;
1266 s->modified_quant=1;
1270 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1272 case CODEC_ID_MPEG4:
1273 s->out_format = FMT_H263;
1275 s->unrestricted_mv = 1;
1276 s->low_delay= s->max_b_frames ? 0 : 1;
1277 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1279 case CODEC_ID_MSMPEG4V1:
1280 s->out_format = FMT_H263;
1281 s->h263_msmpeg4 = 1;
1283 s->unrestricted_mv = 1;
1284 s->msmpeg4_version= 1;
1288 case CODEC_ID_MSMPEG4V2:
1289 s->out_format = FMT_H263;
1290 s->h263_msmpeg4 = 1;
1292 s->unrestricted_mv = 1;
1293 s->msmpeg4_version= 2;
1297 case CODEC_ID_MSMPEG4V3:
1298 s->out_format = FMT_H263;
1299 s->h263_msmpeg4 = 1;
1301 s->unrestricted_mv = 1;
1302 s->msmpeg4_version= 3;
1303 s->flipflop_rounding=1;
1308 s->out_format = FMT_H263;
1309 s->h263_msmpeg4 = 1;
1311 s->unrestricted_mv = 1;
1312 s->msmpeg4_version= 4;
1313 s->flipflop_rounding=1;
1318 s->out_format = FMT_H263;
1319 s->h263_msmpeg4 = 1;
1321 s->unrestricted_mv = 1;
1322 s->msmpeg4_version= 5;
1323 s->flipflop_rounding=1;
1331 avctx->has_b_frames= !s->low_delay;
1336 if (MPV_common_init(s) < 0)
1339 if(s->modified_quant)
1340 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1341 s->progressive_frame=
1342 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1343 s->quant_precision=5;
1345 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1346 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1348 #ifdef CONFIG_H261_ENCODER
1349 if (s->out_format == FMT_H261)
1350 ff_h261_encode_init(s);
1352 if (s->out_format == FMT_H263)
1353 h263_encode_init(s);
1354 if(s->msmpeg4_version)
1355 ff_msmpeg4_encode_init(s);
1356 if (s->out_format == FMT_MPEG1)
1357 ff_mpeg1_encode_init(s);
1361 int j= s->dsp.idct_permutation[i];
1362 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1363 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1364 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1365 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1366 s->intra_matrix[j] =
1367 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1370 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1371 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1373 if(s->avctx->intra_matrix)
1374 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1375 if(s->avctx->inter_matrix)
1376 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1379 /* precompute matrix */
1380 /* for mjpeg, we do include qscale in the matrix */
1381 if (s->out_format != FMT_MJPEG) {
1382 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1383 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1384 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1385 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1388 if(ff_rate_control_init(s) < 0)
1394 int MPV_encode_end(AVCodecContext *avctx)
1396 MpegEncContext *s = avctx->priv_data;
1398 ff_rate_control_uninit(s);
1401 if (s->out_format == FMT_MJPEG)
1404 av_freep(&avctx->extradata);
1409 #endif //CONFIG_ENCODERS
1411 void init_rl(RLTable *rl, int use_static)
1413 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1414 uint8_t index_run[MAX_RUN+1];
1415 int last, run, level, start, end, i;
1417 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1418 if(use_static && rl->max_level[0])
1421 /* compute max_level[], max_run[] and index_run[] */
1422 for(last=0;last<2;last++) {
1431 memset(max_level, 0, MAX_RUN + 1);
1432 memset(max_run, 0, MAX_LEVEL + 1);
1433 memset(index_run, rl->n, MAX_RUN + 1);
1434 for(i=start;i<end;i++) {
1435 run = rl->table_run[i];
1436 level = rl->table_level[i];
1437 if (index_run[run] == rl->n)
1439 if (level > max_level[run])
1440 max_level[run] = level;
1441 if (run > max_run[level])
1442 max_run[level] = run;
1445 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1447 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1448 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1450 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1452 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1453 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1455 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1457 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1458 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1462 /* draw the edges of width 'w' of an image of size width, height */
1463 //FIXME check that this is ok for mpeg4 interlaced
1464 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1466 uint8_t *ptr, *last_line;
1469 last_line = buf + (height - 1) * wrap;
1471 /* top and bottom */
1472 memcpy(buf - (i + 1) * wrap, buf, width);
1473 memcpy(last_line + (i + 1) * wrap, last_line, width);
1475 /* left and right */
1477 for(i=0;i<height;i++) {
1478 memset(ptr - w, ptr[0], w);
1479 memset(ptr + width, ptr[width-1], w);
1484 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1485 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1486 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1487 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1491 int ff_find_unused_picture(MpegEncContext *s, int shared){
1495 for(i=0; i<MAX_PICTURE_COUNT; i++){
1496 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1499 for(i=0; i<MAX_PICTURE_COUNT; i++){
1500 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1502 for(i=0; i<MAX_PICTURE_COUNT; i++){
1503 if(s->picture[i].data[0]==NULL) return i;
1511 static void update_noise_reduction(MpegEncContext *s){
1514 for(intra=0; intra<2; intra++){
1515 if(s->dct_count[intra] > (1<<16)){
1516 for(i=0; i<64; i++){
1517 s->dct_error_sum[intra][i] >>=1;
1519 s->dct_count[intra] >>= 1;
1522 for(i=0; i<64; i++){
1523 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);
1529 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1531 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1537 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1539 /* mark&release old frames */
1540 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1541 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1542 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1544 /* release forgotten pictures */
1545 /* if(mpeg124/h263) */
1547 for(i=0; i<MAX_PICTURE_COUNT; i++){
1548 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1549 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1550 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1558 /* release non reference frames */
1559 for(i=0; i<MAX_PICTURE_COUNT; i++){
1560 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1561 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1565 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1566 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1568 i= ff_find_unused_picture(s, 0);
1569 pic= (AVFrame*)&s->picture[i];
1572 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1573 && !s->dropable ? 3 : 0;
1575 pic->coded_picture_number= s->coded_picture_number++;
1577 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1580 s->current_picture_ptr= (Picture*)pic;
1581 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1582 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1585 s->current_picture_ptr->pict_type= s->pict_type;
1586 // if(s->flags && CODEC_FLAG_QSCALE)
1587 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1588 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1590 copy_picture(&s->current_picture, s->current_picture_ptr);
1592 if (s->pict_type != B_TYPE) {
1593 s->last_picture_ptr= s->next_picture_ptr;
1595 s->next_picture_ptr= s->current_picture_ptr;
1597 /* 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,
1598 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1599 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1600 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1601 s->pict_type, s->dropable);*/
1603 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1604 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1606 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
1607 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1608 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1612 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1614 if(s->picture_structure!=PICT_FRAME){
1617 if(s->picture_structure == PICT_BOTTOM_FIELD){
1618 s->current_picture.data[i] += s->current_picture.linesize[i];
1620 s->current_picture.linesize[i] *= 2;
1621 s->last_picture.linesize[i] *=2;
1622 s->next_picture.linesize[i] *=2;
1626 s->hurry_up= s->avctx->hurry_up;
1627 s->error_resilience= avctx->error_resilience;
1629 /* set dequantizer, we can't do it during init as it might change for mpeg4
1630 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1631 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1632 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1633 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1634 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1635 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1636 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1638 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1639 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1642 if(s->dct_error_sum){
1643 assert(s->avctx->noise_reduction && s->encoding);
1645 update_noise_reduction(s);
1649 if(s->avctx->xvmc_acceleration)
1650 return XVMC_field_start(s, avctx);
1655 /* generic function for encode/decode called after a frame has been coded/decoded */
1656 void MPV_frame_end(MpegEncContext *s)
1659 /* draw edge for correct motion prediction if outside */
1661 //just to make sure that all data is rendered.
1662 if(s->avctx->xvmc_acceleration){
1666 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1667 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1668 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1669 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1673 s->last_pict_type = s->pict_type;
1674 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1675 if(s->pict_type!=B_TYPE){
1676 s->last_non_b_pict_type= s->pict_type;
1679 /* copy back current_picture variables */
1680 for(i=0; i<MAX_PICTURE_COUNT; i++){
1681 if(s->picture[i].data[0] == s->current_picture.data[0]){
1682 s->picture[i]= s->current_picture;
1686 assert(i<MAX_PICTURE_COUNT);
1690 /* release non-reference frames */
1691 for(i=0; i<MAX_PICTURE_COUNT; i++){
1692 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1693 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1697 // clear copies, to avoid confusion
1699 memset(&s->last_picture, 0, sizeof(Picture));
1700 memset(&s->next_picture, 0, sizeof(Picture));
1701 memset(&s->current_picture, 0, sizeof(Picture));
1703 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1707 * draws an line from (ex, ey) -> (sx, sy).
1708 * @param w width of the image
1709 * @param h height of the image
1710 * @param stride stride/linesize of the image
1711 * @param color color of the arrow
1713 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1716 sx= av_clip(sx, 0, w-1);
1717 sy= av_clip(sy, 0, h-1);
1718 ex= av_clip(ex, 0, w-1);
1719 ey= av_clip(ey, 0, h-1);
1721 buf[sy*stride + sx]+= color;
1723 if(FFABS(ex - sx) > FFABS(ey - sy)){
1725 FFSWAP(int, sx, ex);
1726 FFSWAP(int, sy, ey);
1728 buf+= sx + sy*stride;
1730 f= ((ey-sy)<<16)/ex;
1731 for(x= 0; x <= ex; x++){
1734 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1735 buf[(y+1)*stride + x]+= (color* fr )>>16;
1739 FFSWAP(int, sx, ex);
1740 FFSWAP(int, sy, ey);
1742 buf+= sx + sy*stride;
1744 if(ey) f= ((ex-sx)<<16)/ey;
1746 for(y= 0; y <= ey; y++){
1749 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1750 buf[y*stride + x+1]+= (color* fr )>>16;;
1756 * draws an arrow from (ex, ey) -> (sx, sy).
1757 * @param w width of the image
1758 * @param h height of the image
1759 * @param stride stride/linesize of the image
1760 * @param color color of the arrow
1762 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1765 sx= av_clip(sx, -100, w+100);
1766 sy= av_clip(sy, -100, h+100);
1767 ex= av_clip(ex, -100, w+100);
1768 ey= av_clip(ey, -100, h+100);
1773 if(dx*dx + dy*dy > 3*3){
1776 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1778 //FIXME subpixel accuracy
1779 rx= ROUNDED_DIV(rx*3<<4, length);
1780 ry= ROUNDED_DIV(ry*3<<4, length);
1782 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1783 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1785 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1789 * prints debuging info for the given picture.
1791 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1793 if(!pict || !pict->mb_type) return;
1795 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1798 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1799 switch (pict->pict_type) {
1800 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1801 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1802 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1803 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1804 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1805 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1807 for(y=0; y<s->mb_height; y++){
1808 for(x=0; x<s->mb_width; x++){
1809 if(s->avctx->debug&FF_DEBUG_SKIP){
1810 int count= s->mbskip_table[x + y*s->mb_stride];
1811 if(count>9) count=9;
1812 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1814 if(s->avctx->debug&FF_DEBUG_QP){
1815 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1817 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1818 int mb_type= pict->mb_type[x + y*s->mb_stride];
1819 //Type & MV direction
1821 av_log(s->avctx, AV_LOG_DEBUG, "P");
1822 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1823 av_log(s->avctx, AV_LOG_DEBUG, "A");
1824 else if(IS_INTRA4x4(mb_type))
1825 av_log(s->avctx, AV_LOG_DEBUG, "i");
1826 else if(IS_INTRA16x16(mb_type))
1827 av_log(s->avctx, AV_LOG_DEBUG, "I");
1828 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1829 av_log(s->avctx, AV_LOG_DEBUG, "d");
1830 else if(IS_DIRECT(mb_type))
1831 av_log(s->avctx, AV_LOG_DEBUG, "D");
1832 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1833 av_log(s->avctx, AV_LOG_DEBUG, "g");
1834 else if(IS_GMC(mb_type))
1835 av_log(s->avctx, AV_LOG_DEBUG, "G");
1836 else if(IS_SKIP(mb_type))
1837 av_log(s->avctx, AV_LOG_DEBUG, "S");
1838 else if(!USES_LIST(mb_type, 1))
1839 av_log(s->avctx, AV_LOG_DEBUG, ">");
1840 else if(!USES_LIST(mb_type, 0))
1841 av_log(s->avctx, AV_LOG_DEBUG, "<");
1843 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1844 av_log(s->avctx, AV_LOG_DEBUG, "X");
1849 av_log(s->avctx, AV_LOG_DEBUG, "+");
1850 else if(IS_16X8(mb_type))
1851 av_log(s->avctx, AV_LOG_DEBUG, "-");
1852 else if(IS_8X16(mb_type))
1853 av_log(s->avctx, AV_LOG_DEBUG, "|");
1854 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1855 av_log(s->avctx, AV_LOG_DEBUG, " ");
1857 av_log(s->avctx, AV_LOG_DEBUG, "?");
1860 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1861 av_log(s->avctx, AV_LOG_DEBUG, "=");
1863 av_log(s->avctx, AV_LOG_DEBUG, " ");
1865 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1867 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1871 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1872 const int shift= 1 + s->quarter_sample;
1876 int h_chroma_shift, v_chroma_shift;
1877 const int width = s->avctx->width;
1878 const int height= s->avctx->height;
1879 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1880 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1881 s->low_delay=0; //needed to see the vectors without trashing the buffers
1883 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1885 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1886 pict->data[i]= s->visualization_buffer[i];
1888 pict->type= FF_BUFFER_TYPE_COPY;
1891 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1893 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1894 const int mb_index= mb_x + mb_y*s->mb_stride;
1895 if((s->avctx->debug_mv) && pict->motion_val){
1897 for(type=0; type<3; type++){
1900 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1904 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1908 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1913 if(!USES_LIST(pict->mb_type[mb_index], direction))
1916 if(IS_8X8(pict->mb_type[mb_index])){
1919 int sx= mb_x*16 + 4 + 8*(i&1);
1920 int sy= mb_y*16 + 4 + 8*(i>>1);
1921 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1922 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1923 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1924 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1926 }else if(IS_16X8(pict->mb_type[mb_index])){
1930 int sy=mb_y*16 + 4 + 8*i;
1931 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1932 int mx=(pict->motion_val[direction][xy][0]>>shift);
1933 int my=(pict->motion_val[direction][xy][1]>>shift);
1935 if(IS_INTERLACED(pict->mb_type[mb_index]))
1938 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1940 }else if(IS_8X16(pict->mb_type[mb_index])){
1943 int sx=mb_x*16 + 4 + 8*i;
1945 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1946 int mx=(pict->motion_val[direction][xy][0]>>shift);
1947 int my=(pict->motion_val[direction][xy][1]>>shift);
1949 if(IS_INTERLACED(pict->mb_type[mb_index]))
1952 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1955 int sx= mb_x*16 + 8;
1956 int sy= mb_y*16 + 8;
1957 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1958 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1959 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1960 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1964 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1965 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1968 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1969 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1972 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1973 int mb_type= pict->mb_type[mb_index];
1976 #define COLOR(theta, r)\
1977 u= (int)(128 + r*cos(theta*3.141592/180));\
1978 v= (int)(128 + r*sin(theta*3.141592/180));
1982 if(IS_PCM(mb_type)){
1984 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1986 }else if(IS_INTRA4x4(mb_type)){
1988 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1990 }else if(IS_DIRECT(mb_type)){
1992 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1994 }else if(IS_GMC(mb_type)){
1996 }else if(IS_SKIP(mb_type)){
1998 }else if(!USES_LIST(mb_type, 1)){
2000 }else if(!USES_LIST(mb_type, 0)){
2003 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2007 u*= 0x0101010101010101ULL;
2008 v*= 0x0101010101010101ULL;
2010 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2011 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2015 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
2016 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2017 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2019 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2021 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2023 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2024 int dm= 1 << (mv_sample_log2-2);
2026 int sx= mb_x*16 + 8*(i&1);
2027 int sy= mb_y*16 + 8*(i>>1);
2028 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2030 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2031 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2033 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2034 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2035 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2039 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2043 s->mbskip_table[mb_index]=0;
2049 #ifdef CONFIG_ENCODERS
2051 static int get_sae(uint8_t *src, int ref, int stride){
2055 for(y=0; y<16; y++){
2056 for(x=0; x<16; x++){
2057 acc+= FFABS(src[x+y*stride] - ref);
2064 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2071 for(y=0; y<h; y+=16){
2072 for(x=0; x<w; x+=16){
2073 int offset= x + y*stride;
2074 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2075 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2076 int sae = get_sae(src + offset, mean, stride);
2078 acc+= sae + 500 < sad;
2085 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2089 const int encoding_delay= s->max_b_frames;
2094 pic_arg->display_picture_number= s->input_picture_number++;
2096 if(pts != AV_NOPTS_VALUE){
2097 if(s->user_specified_pts != AV_NOPTS_VALUE){
2099 int64_t last= s->user_specified_pts;
2102 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2106 s->user_specified_pts= pts;
2108 if(s->user_specified_pts != AV_NOPTS_VALUE){
2109 s->user_specified_pts=
2110 pts= s->user_specified_pts + 1;
2111 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2113 pts= pic_arg->display_picture_number;
2119 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2120 if(pic_arg->linesize[0] != s->linesize) direct=0;
2121 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2122 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2124 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2127 i= ff_find_unused_picture(s, 1);
2129 pic= (AVFrame*)&s->picture[i];
2133 pic->data[i]= pic_arg->data[i];
2134 pic->linesize[i]= pic_arg->linesize[i];
2136 alloc_picture(s, (Picture*)pic, 1);
2138 i= ff_find_unused_picture(s, 0);
2140 pic= (AVFrame*)&s->picture[i];
2143 alloc_picture(s, (Picture*)pic, 0);
2145 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2146 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2147 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2150 int h_chroma_shift, v_chroma_shift;
2151 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2154 int src_stride= pic_arg->linesize[i];
2155 int dst_stride= i ? s->uvlinesize : s->linesize;
2156 int h_shift= i ? h_chroma_shift : 0;
2157 int v_shift= i ? v_chroma_shift : 0;
2158 int w= s->width >>h_shift;
2159 int h= s->height>>v_shift;
2160 uint8_t *src= pic_arg->data[i];
2161 uint8_t *dst= pic->data[i];
2163 if(!s->avctx->rc_buffer_size)
2164 dst +=INPLACE_OFFSET;
2166 if(src_stride==dst_stride)
2167 memcpy(dst, src, src_stride*h);
2170 memcpy(dst, src, w);
2178 copy_picture_attributes(s, pic, pic_arg);
2179 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2182 /* shift buffer entries */
2183 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2184 s->input_picture[i-1]= s->input_picture[i];
2186 s->input_picture[encoding_delay]= (Picture*)pic;
2191 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2196 for(plane=0; plane<3; plane++){
2197 const int stride= p->linesize[plane];
2198 const int bw= plane ? 1 : 2;
2199 for(y=0; y<s->mb_height*bw; y++){
2200 for(x=0; x<s->mb_width*bw; x++){
2201 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2202 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);
2204 switch(s->avctx->frame_skip_exp){
2205 case 0: score= FFMAX(score, v); break;
2206 case 1: score+= FFABS(v);break;
2207 case 2: score+= v*v;break;
2208 case 3: score64+= FFABS(v*v*(int64_t)v);break;
2209 case 4: score64+= v*v*(int64_t)(v*v);break;
2215 if(score) score64= score;
2217 if(score64 < s->avctx->frame_skip_threshold)
2219 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2224 static int estimate_best_b_count(MpegEncContext *s){
2225 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2226 AVCodecContext *c= avcodec_alloc_context();
2227 AVFrame input[FF_MAX_B_FRAMES+2];
2228 const int scale= s->avctx->brd_scale;
2229 int i, j, out_size, p_lambda, b_lambda, lambda2;
2230 int outbuf_size= s->width * s->height; //FIXME
2231 uint8_t *outbuf= av_malloc(outbuf_size);
2232 int64_t best_rd= INT64_MAX;
2233 int best_b_count= -1;
2235 assert(scale>=0 && scale <=3);
2238 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2239 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2240 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2241 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2243 c->width = s->width >> scale;
2244 c->height= s->height>> scale;
2245 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2246 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2247 c->mb_decision= s->avctx->mb_decision;
2248 c->me_cmp= s->avctx->me_cmp;
2249 c->mb_cmp= s->avctx->mb_cmp;
2250 c->me_sub_cmp= s->avctx->me_sub_cmp;
2251 c->pix_fmt = PIX_FMT_YUV420P;
2252 c->time_base= s->avctx->time_base;
2253 c->max_b_frames= s->max_b_frames;
2255 if (avcodec_open(c, codec) < 0)
2258 for(i=0; i<s->max_b_frames+2; i++){
2259 int ysize= c->width*c->height;
2260 int csize= (c->width/2)*(c->height/2);
2261 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2263 avcodec_get_frame_defaults(&input[i]);
2264 input[i].data[0]= av_malloc(ysize + 2*csize);
2265 input[i].data[1]= input[i].data[0] + ysize;
2266 input[i].data[2]= input[i].data[1] + csize;
2267 input[i].linesize[0]= c->width;
2268 input[i].linesize[1]=
2269 input[i].linesize[2]= c->width/2;
2271 if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2272 pre_input= *pre_input_ptr;
2274 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2275 pre_input.data[0]+=INPLACE_OFFSET;
2276 pre_input.data[1]+=INPLACE_OFFSET;
2277 pre_input.data[2]+=INPLACE_OFFSET;
2280 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2281 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);
2282 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);
2286 for(j=0; j<s->max_b_frames+1; j++){
2289 if(!s->input_picture[j])
2292 c->error[0]= c->error[1]= c->error[2]= 0;
2294 input[0].pict_type= I_TYPE;
2295 input[0].quality= 1 * FF_QP2LAMBDA;
2296 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2297 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2299 for(i=0; i<s->max_b_frames+1; i++){
2300 int is_p= i % (j+1) == j || i==s->max_b_frames;
2302 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2303 input[i+1].quality= is_p ? p_lambda : b_lambda;
2304 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2305 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2308 /* get the delayed frames */
2310 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2311 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2314 rd += c->error[0] + c->error[1] + c->error[2];
2326 for(i=0; i<s->max_b_frames+2; i++){
2327 av_freep(&input[i].data[0]);
2330 return best_b_count;
2333 static void select_input_picture(MpegEncContext *s){
2336 for(i=1; i<MAX_PICTURE_COUNT; i++)
2337 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2338 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2340 /* set next picture type & ordering */
2341 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2342 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2343 s->reordered_input_picture[0]= s->input_picture[0];
2344 s->reordered_input_picture[0]->pict_type= I_TYPE;
2345 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2349 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2350 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2351 //FIXME check that te gop check above is +-1 correct
2352 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2354 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2356 s->input_picture[0]->data[i]= NULL;
2357 s->input_picture[0]->type= 0;
2359 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2360 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2362 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2366 ff_vbv_update(s, 0);
2372 if(s->flags&CODEC_FLAG_PASS2){
2373 for(i=0; i<s->max_b_frames+1; i++){
2374 int pict_num= s->input_picture[0]->display_picture_number + i;
2376 if(pict_num >= s->rc_context.num_entries)
2378 if(!s->input_picture[i]){
2379 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2383 s->input_picture[i]->pict_type=
2384 s->rc_context.entry[pict_num].new_pict_type;
2388 if(s->avctx->b_frame_strategy==0){
2389 b_frames= s->max_b_frames;
2390 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2391 }else if(s->avctx->b_frame_strategy==1){
2392 for(i=1; i<s->max_b_frames+1; i++){
2393 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2394 s->input_picture[i]->b_frame_score=
2395 get_intra_count(s, s->input_picture[i ]->data[0],
2396 s->input_picture[i-1]->data[0], s->linesize) + 1;
2399 for(i=0; i<s->max_b_frames+1; i++){
2400 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2403 b_frames= FFMAX(0, i-1);
2406 for(i=0; i<b_frames+1; i++){
2407 s->input_picture[i]->b_frame_score=0;
2409 }else if(s->avctx->b_frame_strategy==2){
2410 b_frames= estimate_best_b_count(s);
2412 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2417 //static int b_count=0;
2418 //b_count+= b_frames;
2419 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2421 for(i= b_frames - 1; i>=0; i--){
2422 int type= s->input_picture[i]->pict_type;
2423 if(type && type != B_TYPE)
2426 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2427 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2430 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2431 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2432 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2434 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2436 s->input_picture[b_frames]->pict_type= I_TYPE;
2440 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2442 && s->input_picture[b_frames]->pict_type== I_TYPE)
2445 s->reordered_input_picture[0]= s->input_picture[b_frames];
2446 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2447 s->reordered_input_picture[0]->pict_type= P_TYPE;
2448 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2449 for(i=0; i<b_frames; i++){
2450 s->reordered_input_picture[i+1]= s->input_picture[i];
2451 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2452 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2457 if(s->reordered_input_picture[0]){
2458 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2460 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2462 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
2463 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2465 int i= ff_find_unused_picture(s, 0);
2466 Picture *pic= &s->picture[i];
2468 pic->reference = s->reordered_input_picture[0]->reference;
2469 alloc_picture(s, pic, 0);
2471 /* mark us unused / free shared pic */
2472 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2473 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2475 s->reordered_input_picture[0]->data[i]= NULL;
2476 s->reordered_input_picture[0]->type= 0;
2478 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2480 s->current_picture_ptr= pic;
2482 // input is not a shared pix -> reuse buffer for current_pix
2484 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2485 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2487 s->current_picture_ptr= s->reordered_input_picture[0];
2489 s->new_picture.data[i]+= INPLACE_OFFSET;
2492 copy_picture(&s->current_picture, s->current_picture_ptr);
2494 s->picture_number= s->new_picture.display_picture_number;
2495 //printf("dpn:%d\n", s->picture_number);
2497 memset(&s->new_picture, 0, sizeof(Picture));
2501 int MPV_encode_picture(AVCodecContext *avctx,
2502 unsigned char *buf, int buf_size, void *data)
2504 MpegEncContext *s = avctx->priv_data;
2505 AVFrame *pic_arg = data;
2506 int i, stuffing_count;
2508 for(i=0; i<avctx->thread_count; i++){
2509 int start_y= s->thread_context[i]->start_mb_y;
2510 int end_y= s->thread_context[i]-> end_mb_y;
2511 int h= s->mb_height;
2512 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2513 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2515 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2518 s->picture_in_gop_number++;
2520 if(load_input_picture(s, pic_arg) < 0)
2523 select_input_picture(s);
2526 if(s->new_picture.data[0]){
2527 s->pict_type= s->new_picture.pict_type;
2529 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2530 MPV_frame_start(s, avctx);
2532 if (encode_picture(s, s->picture_number) < 0)
2535 avctx->real_pict_num = s->picture_number;
2536 avctx->header_bits = s->header_bits;
2537 avctx->mv_bits = s->mv_bits;
2538 avctx->misc_bits = s->misc_bits;
2539 avctx->i_tex_bits = s->i_tex_bits;
2540 avctx->p_tex_bits = s->p_tex_bits;
2541 avctx->i_count = s->i_count;
2542 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2543 avctx->skip_count = s->skip_count;
2547 if (s->out_format == FMT_MJPEG)
2548 mjpeg_picture_trailer(s);
2550 if(avctx->rc_buffer_size){
2551 RateControlContext *rcc= &s->rc_context;
2552 int max_size= rcc->buffer_index/3;
2554 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2555 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2556 if(s->adaptive_quant){
2558 for(i=0; i<s->mb_height*s->mb_stride; i++)
2559 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
2561 s->mb_skipped = 0; //done in MPV_frame_start()
2562 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2563 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2564 s->no_rounding ^= 1;
2566 if(s->pict_type!=B_TYPE){
2567 s->time_base= s->last_time_base;
2568 s->last_non_b_time= s->time - s->pp_time;
2570 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2571 for(i=0; i<avctx->thread_count; i++){
2572 PutBitContext *pb= &s->thread_context[i]->pb;
2573 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2578 assert(s->avctx->rc_max_rate);
2581 if(s->flags&CODEC_FLAG_PASS1)
2582 ff_write_pass1_stats(s);
2585 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2586 avctx->error[i] += s->current_picture_ptr->error[i];
2589 if(s->flags&CODEC_FLAG_PASS1)
2590 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2591 flush_put_bits(&s->pb);
2592 s->frame_bits = put_bits_count(&s->pb);
2594 stuffing_count= ff_vbv_update(s, s->frame_bits);
2596 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2597 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2601 switch(s->codec_id){
2602 case CODEC_ID_MPEG1VIDEO:
2603 case CODEC_ID_MPEG2VIDEO:
2604 while(stuffing_count--){
2605 put_bits(&s->pb, 8, 0);
2608 case CODEC_ID_MPEG4:
2609 put_bits(&s->pb, 16, 0);
2610 put_bits(&s->pb, 16, 0x1C3);
2611 stuffing_count -= 4;
2612 while(stuffing_count--){
2613 put_bits(&s->pb, 8, 0xFF);
2617 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2619 flush_put_bits(&s->pb);
2620 s->frame_bits = put_bits_count(&s->pb);
2623 /* update mpeg1/2 vbv_delay for CBR */
2624 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2625 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2628 assert(s->repeat_first_field==0);
2630 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2631 assert(vbv_delay < 0xFFFF);
2633 s->vbv_delay_ptr[0] &= 0xF8;
2634 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2635 s->vbv_delay_ptr[1] = vbv_delay>>5;
2636 s->vbv_delay_ptr[2] &= 0x07;
2637 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2639 s->total_bits += s->frame_bits;
2640 avctx->frame_bits = s->frame_bits;
2642 assert((pbBufPtr(&s->pb) == s->pb.buf));
2645 assert((s->frame_bits&7)==0);
2647 return s->frame_bits/8;
2650 #endif //CONFIG_ENCODERS
2652 static inline void gmc1_motion(MpegEncContext *s,
2653 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2654 uint8_t **ref_picture)
2657 int offset, src_x, src_y, linesize, uvlinesize;
2658 int motion_x, motion_y;
2661 motion_x= s->sprite_offset[0][0];
2662 motion_y= s->sprite_offset[0][1];
2663 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2664 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2665 motion_x<<=(3-s->sprite_warping_accuracy);
2666 motion_y<<=(3-s->sprite_warping_accuracy);
2667 src_x = av_clip(src_x, -16, s->width);
2668 if (src_x == s->width)
2670 src_y = av_clip(src_y, -16, s->height);
2671 if (src_y == s->height)
2674 linesize = s->linesize;
2675 uvlinesize = s->uvlinesize;
2677 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2679 if(s->flags&CODEC_FLAG_EMU_EDGE){
2680 if( (unsigned)src_x >= s->h_edge_pos - 17
2681 || (unsigned)src_y >= s->v_edge_pos - 17){
2682 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2683 ptr= s->edge_emu_buffer;
2687 if((motion_x|motion_y)&7){
2688 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2689 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2693 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2694 if (s->no_rounding){
2695 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2697 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2701 if(s->flags&CODEC_FLAG_GRAY) return;
2703 motion_x= s->sprite_offset[1][0];
2704 motion_y= s->sprite_offset[1][1];
2705 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2706 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2707 motion_x<<=(3-s->sprite_warping_accuracy);
2708 motion_y<<=(3-s->sprite_warping_accuracy);
2709 src_x = av_clip(src_x, -8, s->width>>1);
2710 if (src_x == s->width>>1)
2712 src_y = av_clip(src_y, -8, s->height>>1);
2713 if (src_y == s->height>>1)
2716 offset = (src_y * uvlinesize) + src_x;
2717 ptr = ref_picture[1] + offset;
2718 if(s->flags&CODEC_FLAG_EMU_EDGE){
2719 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2720 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2721 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);
2722 ptr= s->edge_emu_buffer;
2726 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2728 ptr = ref_picture[2] + offset;
2730 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);
2731 ptr= s->edge_emu_buffer;
2733 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2738 static inline void gmc_motion(MpegEncContext *s,
2739 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2740 uint8_t **ref_picture)
2743 int linesize, uvlinesize;
2744 const int a= s->sprite_warping_accuracy;
2747 linesize = s->linesize;
2748 uvlinesize = s->uvlinesize;
2750 ptr = ref_picture[0];
2752 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2753 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2755 s->dsp.gmc(dest_y, ptr, linesize, 16,
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, s->v_edge_pos);
2762 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2763 ox + s->sprite_delta[0][0]*8,
2764 oy + s->sprite_delta[1][0]*8,
2765 s->sprite_delta[0][0], s->sprite_delta[0][1],
2766 s->sprite_delta[1][0], s->sprite_delta[1][1],
2767 a+1, (1<<(2*a+1)) - s->no_rounding,
2768 s->h_edge_pos, s->v_edge_pos);
2770 if(s->flags&CODEC_FLAG_GRAY) return;
2772 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2773 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2775 ptr = ref_picture[1];
2776 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2779 s->sprite_delta[0][0], s->sprite_delta[0][1],
2780 s->sprite_delta[1][0], s->sprite_delta[1][1],
2781 a+1, (1<<(2*a+1)) - s->no_rounding,
2782 s->h_edge_pos>>1, s->v_edge_pos>>1);
2784 ptr = ref_picture[2];
2785 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2788 s->sprite_delta[0][0], s->sprite_delta[0][1],
2789 s->sprite_delta[1][0], s->sprite_delta[1][1],
2790 a+1, (1<<(2*a+1)) - s->no_rounding,
2791 s->h_edge_pos>>1, s->v_edge_pos>>1);
2795 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2796 * @param buf destination buffer
2797 * @param src source buffer
2798 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2799 * @param block_w width of block
2800 * @param block_h height of block
2801 * @param src_x x coordinate of the top left sample of the block in the source buffer
2802 * @param src_y y coordinate of the top left sample of the block in the source buffer
2803 * @param w width of the source buffer
2804 * @param h height of the source buffer
2806 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2807 int src_x, int src_y, int w, int h){
2809 int start_y, start_x, end_y, end_x;
2812 src+= (h-1-src_y)*linesize;
2814 }else if(src_y<=-block_h){
2815 src+= (1-block_h-src_y)*linesize;
2821 }else if(src_x<=-block_w){
2822 src+= (1-block_w-src_x);
2826 start_y= FFMAX(0, -src_y);
2827 start_x= FFMAX(0, -src_x);
2828 end_y= FFMIN(block_h, h-src_y);
2829 end_x= FFMIN(block_w, w-src_x);
2831 // copy existing part
2832 for(y=start_y; y<end_y; y++){
2833 for(x=start_x; x<end_x; x++){
2834 buf[x + y*linesize]= src[x + y*linesize];
2839 for(y=0; y<start_y; y++){
2840 for(x=start_x; x<end_x; x++){
2841 buf[x + y*linesize]= buf[x + start_y*linesize];
2846 for(y=end_y; y<block_h; y++){
2847 for(x=start_x; x<end_x; x++){
2848 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2852 for(y=0; y<block_h; y++){
2854 for(x=0; x<start_x; x++){
2855 buf[x + y*linesize]= buf[start_x + y*linesize];
2859 for(x=end_x; x<block_w; x++){
2860 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2865 static inline int hpel_motion(MpegEncContext *s,
2866 uint8_t *dest, uint8_t *src,
2867 int field_based, int field_select,
2868 int src_x, int src_y,
2869 int width, int height, int stride,
2870 int h_edge_pos, int v_edge_pos,
2871 int w, int h, op_pixels_func *pix_op,
2872 int motion_x, int motion_y)
2877 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2878 src_x += motion_x >> 1;
2879 src_y += motion_y >> 1;
2881 /* WARNING: do no forget half pels */
2882 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
2885 src_y = av_clip(src_y, -16, height);
2886 if (src_y == height)
2888 src += src_y * stride + src_x;
2890 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2891 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2892 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2893 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2894 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2895 src= s->edge_emu_buffer;
2901 pix_op[dxy](dest, src, stride, h);
2905 static inline int hpel_motion_lowres(MpegEncContext *s,
2906 uint8_t *dest, uint8_t *src,
2907 int field_based, int field_select,
2908 int src_x, int src_y,
2909 int width, int height, int stride,
2910 int h_edge_pos, int v_edge_pos,
2911 int w, int h, h264_chroma_mc_func *pix_op,
2912 int motion_x, int motion_y)
2914 const int lowres= s->avctx->lowres;
2915 const int s_mask= (2<<lowres)-1;
2919 if(s->quarter_sample){
2924 sx= motion_x & s_mask;
2925 sy= motion_y & s_mask;
2926 src_x += motion_x >> (lowres+1);
2927 src_y += motion_y >> (lowres+1);
2929 src += src_y * stride + src_x;
2931 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2932 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2933 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2934 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2935 src= s->edge_emu_buffer;
2943 pix_op[lowres](dest, src, stride, h, sx, sy);
2947 /* apply one mpeg motion vector to the three components */
2948 static av_always_inline void mpeg_motion(MpegEncContext *s,
2949 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2950 int field_based, int bottom_field, int field_select,
2951 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2952 int motion_x, int motion_y, int h)
2954 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2955 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2958 if(s->quarter_sample)
2965 v_edge_pos = s->v_edge_pos >> field_based;
2966 linesize = s->current_picture.linesize[0] << field_based;
2967 uvlinesize = s->current_picture.linesize[1] << field_based;
2969 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2970 src_x = s->mb_x* 16 + (motion_x >> 1);
2971 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2973 if (s->out_format == FMT_H263) {
2974 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2975 mx = (motion_x>>1)|(motion_x&1);
2977 uvdxy = ((my & 1) << 1) | (mx & 1);
2978 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2979 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2981 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2985 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2989 uvsrc_x = s->mb_x*8 + mx;
2990 uvsrc_y = s->mb_y*8 + my;
2992 if(s->chroma_y_shift){
2995 uvdxy = ((my & 1) << 1) | (mx & 1);
2996 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2997 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2999 if(s->chroma_x_shift){
3002 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
3003 uvsrc_x = s->mb_x* 8 + (mx >> 1);
3014 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3015 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3016 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3018 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
3019 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
3020 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3021 s->codec_id == CODEC_ID_MPEG1VIDEO){
3022 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3025 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3026 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3027 ptr_y = s->edge_emu_buffer;
3028 if(!(s->flags&CODEC_FLAG_GRAY)){
3029 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3030 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3031 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3032 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3033 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3039 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3040 dest_y += s->linesize;
3041 dest_cb+= s->uvlinesize;
3042 dest_cr+= s->uvlinesize;
3046 ptr_y += s->linesize;
3047 ptr_cb+= s->uvlinesize;
3048 ptr_cr+= s->uvlinesize;
3051 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3053 if(!(s->flags&CODEC_FLAG_GRAY)){
3054 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3055 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3057 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3058 if(s->out_format == FMT_H261){
3059 ff_h261_loop_filter(s);
3064 /* apply one mpeg motion vector to the three components */
3065 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
3066 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3067 int field_based, int bottom_field, int field_select,
3068 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3069 int motion_x, int motion_y, int h)
3071 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3072 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3073 const int lowres= s->avctx->lowres;
3074 const int block_s= 8>>lowres;
3075 const int s_mask= (2<<lowres)-1;
3076 const int h_edge_pos = s->h_edge_pos >> lowres;
3077 const int v_edge_pos = s->v_edge_pos >> lowres;
3078 linesize = s->current_picture.linesize[0] << field_based;
3079 uvlinesize = s->current_picture.linesize[1] << field_based;
3081 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3087 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3090 sx= motion_x & s_mask;
3091 sy= motion_y & s_mask;
3092 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3093 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3095 if (s->out_format == FMT_H263) {
3096 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3097 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3100 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3103 uvsx = (2*mx) & s_mask;
3104 uvsy = (2*my) & s_mask;
3105 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3106 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3112 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3113 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3116 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3117 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3118 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3120 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3121 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3122 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3123 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3124 ptr_y = s->edge_emu_buffer;
3125 if(!(s->flags&CODEC_FLAG_GRAY)){
3126 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3127 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3128 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3129 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3130 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3136 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3137 dest_y += s->linesize;
3138 dest_cb+= s->uvlinesize;
3139 dest_cr+= s->uvlinesize;
3143 ptr_y += s->linesize;
3144 ptr_cb+= s->uvlinesize;
3145 ptr_cr+= s->uvlinesize;
3150 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3152 if(!(s->flags&CODEC_FLAG_GRAY)){
3153 uvsx <<= 2 - lowres;
3154 uvsy <<= 2 - lowres;
3155 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3156 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3158 //FIXME h261 lowres loop filter
3161 //FIXME move to dsputil, avg variant, 16x16 version
3162 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3164 uint8_t * const top = src[1];
3165 uint8_t * const left = src[2];
3166 uint8_t * const mid = src[0];
3167 uint8_t * const right = src[3];
3168 uint8_t * const bottom= src[4];
3169 #define OBMC_FILTER(x, t, l, m, r, b)\
3170 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3171 #define OBMC_FILTER4(x, t, l, m, r, b)\
3172 OBMC_FILTER(x , t, l, m, r, b);\
3173 OBMC_FILTER(x+1 , t, l, m, r, b);\
3174 OBMC_FILTER(x +stride, t, l, m, r, b);\
3175 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3178 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3179 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3180 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3181 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3182 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3183 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3185 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3186 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3187 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3188 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3190 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3191 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3192 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3193 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3195 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3196 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3197 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3198 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3200 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3201 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3202 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3203 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3204 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3205 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3207 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3208 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3209 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3210 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3213 /* obmc for 1 8x8 luma block */
3214 static inline void obmc_motion(MpegEncContext *s,
3215 uint8_t *dest, uint8_t *src,
3216 int src_x, int src_y,
3217 op_pixels_func *pix_op,
3218 int16_t mv[5][2]/* mid top left right bottom*/)
3224 assert(s->quarter_sample==0);
3227 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3230 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3231 hpel_motion(s, ptr[i], src, 0, 0,
3233 s->width, s->height, s->linesize,
3234 s->h_edge_pos, s->v_edge_pos,
3236 mv[i][0], mv[i][1]);
3240 put_obmc(dest, ptr, s->linesize);
3243 static inline void qpel_motion(MpegEncContext *s,
3244 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3245 int field_based, int bottom_field, int field_select,
3246 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3247 qpel_mc_func (*qpix_op)[16],
3248 int motion_x, int motion_y, int h)
3250 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3251 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3253 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3254 src_x = s->mb_x * 16 + (motion_x >> 2);
3255 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3257 v_edge_pos = s->v_edge_pos >> field_based;
3258 linesize = s->linesize << field_based;
3259 uvlinesize = s->uvlinesize << field_based;
3264 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3265 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3266 mx= (motion_x>>1) + rtab[motion_x&7];
3267 my= (motion_y>>1) + rtab[motion_y&7];
3268 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3269 mx= (motion_x>>1)|(motion_x&1);
3270 my= (motion_y>>1)|(motion_y&1);
3278 uvdxy= (mx&1) | ((my&1)<<1);
3282 uvsrc_x = s->mb_x * 8 + mx;
3283 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3285 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3286 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3287 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3289 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3290 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3291 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3292 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3293 ptr_y= s->edge_emu_buffer;
3294 if(!(s->flags&CODEC_FLAG_GRAY)){
3295 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3296 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3297 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3298 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3299 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3306 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3309 dest_y += s->linesize;
3310 dest_cb+= s->uvlinesize;
3311 dest_cr+= s->uvlinesize;
3315 ptr_y += s->linesize;
3316 ptr_cb += s->uvlinesize;
3317 ptr_cr += s->uvlinesize;
3319 //damn interlaced mode
3320 //FIXME boundary mirroring is not exactly correct here
3321 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3322 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3324 if(!(s->flags&CODEC_FLAG_GRAY)){
3325 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3326 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3330 inline int ff_h263_round_chroma(int x){
3332 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3335 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3340 * h263 chorma 4mv motion compensation.
3342 static inline void chroma_4mv_motion(MpegEncContext *s,
3343 uint8_t *dest_cb, uint8_t *dest_cr,
3344 uint8_t **ref_picture,
3345 op_pixels_func *pix_op,
3347 int dxy, emu=0, src_x, src_y, offset;
3350 /* In case of 8X8, we construct a single chroma motion vector
3351 with a special rounding */
3352 mx= ff_h263_round_chroma(mx);
3353 my= ff_h263_round_chroma(my);
3355 dxy = ((my & 1) << 1) | (mx & 1);
3359 src_x = s->mb_x * 8 + mx;
3360 src_y = s->mb_y * 8 + my;
3361 src_x = av_clip(src_x, -8, s->width/2);
3362 if (src_x == s->width/2)
3364 src_y = av_clip(src_y, -8, s->height/2);
3365 if (src_y == s->height/2)
3368 offset = (src_y * (s->uvlinesize)) + src_x;
3369 ptr = ref_picture[1] + offset;
3370 if(s->flags&CODEC_FLAG_EMU_EDGE){
3371 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3372 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3373 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);
3374 ptr= s->edge_emu_buffer;
3378 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3380 ptr = ref_picture[2] + offset;
3382 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);
3383 ptr= s->edge_emu_buffer;
3385 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3388 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3389 uint8_t *dest_cb, uint8_t *dest_cr,
3390 uint8_t **ref_picture,
3391 h264_chroma_mc_func *pix_op,
3393 const int lowres= s->avctx->lowres;
3394 const int block_s= 8>>lowres;
3395 const int s_mask= (2<<lowres)-1;
3396 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3397 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3398 int emu=0, src_x, src_y, offset, sx, sy;
3401 if(s->quarter_sample){
3406 /* In case of 8X8, we construct a single chroma motion vector
3407 with a special rounding */
3408 mx= ff_h263_round_chroma(mx);
3409 my= ff_h263_round_chroma(my);
3413 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3414 src_y = s->mb_y*block_s + (my >> (lowres+1));
3416 offset = src_y * s->uvlinesize + src_x;
3417 ptr = ref_picture[1] + offset;
3418 if(s->flags&CODEC_FLAG_EMU_EDGE){
3419 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3420 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3421 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3422 ptr= s->edge_emu_buffer;
3428 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3430 ptr = ref_picture[2] + offset;
3432 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3433 ptr= s->edge_emu_buffer;
3435 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3438 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3439 /* fetch pixels for estimated mv 4 macroblocks ahead
3440 * optimized for 64byte cache lines */
3441 const int shift = s->quarter_sample ? 2 : 1;
3442 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3443 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3444 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3445 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3446 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3447 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3451 * motion compensation of a single macroblock
3453 * @param dest_y luma destination pointer
3454 * @param dest_cb chroma cb/u destination pointer
3455 * @param dest_cr chroma cr/v destination pointer
3456 * @param dir direction (0->forward, 1->backward)
3457 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3458 * @param pic_op halfpel motion compensation function (average or put normally)
3459 * @param pic_op qpel motion compensation function (average or put normally)
3460 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3462 static inline void MPV_motion(MpegEncContext *s,
3463 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3464 int dir, uint8_t **ref_picture,
3465 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3467 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3469 uint8_t *ptr, *dest;
3474 prefetch_motion(s, ref_picture, dir);
3476 if(s->obmc && s->pict_type != B_TYPE){
3477 int16_t mv_cache[4][4][2];
3478 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3479 const int mot_stride= s->b8_stride;
3480 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3482 assert(!s->mb_skipped);
3484 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3485 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3486 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3488 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3489 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3491 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3494 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3495 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3496 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3498 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3499 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3502 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3503 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3504 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3506 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3507 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3513 const int x= (i&1)+1;
3514 const int y= (i>>1)+1;
3516 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3517 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3518 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3519 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3520 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3522 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3524 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3531 if(!(s->flags&CODEC_FLAG_GRAY))
3532 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3537 switch(s->mv_type) {
3540 if(s->real_sprite_warping_points==1){
3541 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3544 gmc_motion(s, dest_y, dest_cb, dest_cr,
3547 }else if(s->quarter_sample){
3548 qpel_motion(s, dest_y, dest_cb, dest_cr,
3550 ref_picture, pix_op, qpix_op,
3551 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3553 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3554 ref_picture, pix_op,
3555 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3558 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3560 ref_picture, pix_op,
3561 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3567 if(s->quarter_sample){
3569 motion_x = s->mv[dir][i][0];
3570 motion_y = s->mv[dir][i][1];
3572 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3573 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3574 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3576 /* WARNING: do no forget half pels */
3577 src_x = av_clip(src_x, -16, s->width);
3578 if (src_x == s->width)
3580 src_y = av_clip(src_y, -16, s->height);
3581 if (src_y == s->height)
3584 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3585 if(s->flags&CODEC_FLAG_EMU_EDGE){
3586 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3587 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3588 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);
3589 ptr= s->edge_emu_buffer;
3592 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3593 qpix_op[1][dxy](dest, ptr, s->linesize);
3595 mx += s->mv[dir][i][0]/2;
3596 my += s->mv[dir][i][1]/2;
3600 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3601 ref_picture[0], 0, 0,
3602 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3603 s->width, s->height, s->linesize,
3604 s->h_edge_pos, s->v_edge_pos,
3606 s->mv[dir][i][0], s->mv[dir][i][1]);
3608 mx += s->mv[dir][i][0];
3609 my += s->mv[dir][i][1];
3613 if(!(s->flags&CODEC_FLAG_GRAY))
3614 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3617 if (s->picture_structure == PICT_FRAME) {
3618 if(s->quarter_sample){
3620 qpel_motion(s, dest_y, dest_cb, dest_cr,
3621 1, i, s->field_select[dir][i],
3622 ref_picture, pix_op, qpix_op,
3623 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3627 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3628 1, 0, s->field_select[dir][0],
3629 ref_picture, pix_op,
3630 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3632 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3633 1, 1, s->field_select[dir][1],
3634 ref_picture, pix_op,
3635 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3638 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3639 ref_picture= s->current_picture_ptr->data;
3642 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3643 0, 0, s->field_select[dir][0],
3644 ref_picture, pix_op,
3645 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3650 uint8_t ** ref2picture;
3652 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3653 ref2picture= ref_picture;
3655 ref2picture= s->current_picture_ptr->data;
3658 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3659 0, 0, s->field_select[dir][i],
3660 ref2picture, pix_op,
3661 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3663 dest_y += 16*s->linesize;
3664 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3665 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3669 if(s->picture_structure == PICT_FRAME){
3673 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3675 ref_picture, pix_op,
3676 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3678 pix_op = s->dsp.avg_pixels_tab;
3682 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3683 0, 0, s->picture_structure != i+1,
3684 ref_picture, pix_op,
3685 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3687 // after put we make avg of the same block
3688 pix_op=s->dsp.avg_pixels_tab;
3690 //opposite parity is always in the same frame if this is second field
3691 if(!s->first_field){
3692 ref_picture = s->current_picture_ptr->data;
3702 * motion compensation of a single macroblock
3704 * @param dest_y luma destination pointer
3705 * @param dest_cb chroma cb/u destination pointer
3706 * @param dest_cr chroma cr/v destination pointer
3707 * @param dir direction (0->forward, 1->backward)
3708 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3709 * @param pic_op halfpel motion compensation function (average or put normally)
3710 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3712 static inline void MPV_motion_lowres(MpegEncContext *s,
3713 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3714 int dir, uint8_t **ref_picture,
3715 h264_chroma_mc_func *pix_op)
3719 const int lowres= s->avctx->lowres;
3720 const int block_s= 8>>lowres;
3725 switch(s->mv_type) {
3727 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3729 ref_picture, pix_op,
3730 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3736 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3737 ref_picture[0], 0, 0,
3738 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3739 s->width, s->height, s->linesize,
3740 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3741 block_s, block_s, pix_op,
3742 s->mv[dir][i][0], s->mv[dir][i][1]);
3744 mx += s->mv[dir][i][0];
3745 my += s->mv[dir][i][1];
3748 if(!(s->flags&CODEC_FLAG_GRAY))
3749 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3752 if (s->picture_structure == PICT_FRAME) {
3754 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3755 1, 0, s->field_select[dir][0],
3756 ref_picture, pix_op,
3757 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3759 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3760 1, 1, s->field_select[dir][1],
3761 ref_picture, pix_op,
3762 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3764 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3765 ref_picture= s->current_picture_ptr->data;
3768 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3769 0, 0, s->field_select[dir][0],
3770 ref_picture, pix_op,
3771 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3776 uint8_t ** ref2picture;
3778 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3779 ref2picture= ref_picture;
3781 ref2picture= s->current_picture_ptr->data;
3784 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3785 0, 0, s->field_select[dir][i],
3786 ref2picture, pix_op,
3787 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3789 dest_y += 2*block_s*s->linesize;
3790 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3791 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3795 if(s->picture_structure == PICT_FRAME){
3799 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3801 ref_picture, pix_op,
3802 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3804 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3808 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3809 0, 0, s->picture_structure != i+1,
3810 ref_picture, pix_op,
3811 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3813 // after put we make avg of the same block
3814 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3816 //opposite parity is always in the same frame if this is second field
3817 if(!s->first_field){
3818 ref_picture = s->current_picture_ptr->data;
3827 /* put block[] to dest[] */
3828 static inline void put_dct(MpegEncContext *s,
3829 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3831 s->dct_unquantize_intra(s, block, i, qscale);
3832 s->dsp.idct_put (dest, line_size, block);
3835 /* add block[] to dest[] */
3836 static inline void add_dct(MpegEncContext *s,
3837 DCTELEM *block, int i, uint8_t *dest, int line_size)
3839 if (s->block_last_index[i] >= 0) {
3840 s->dsp.idct_add (dest, line_size, block);
3844 static inline void add_dequant_dct(MpegEncContext *s,
3845 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3847 if (s->block_last_index[i] >= 0) {
3848 s->dct_unquantize_inter(s, block, i, qscale);
3850 s->dsp.idct_add (dest, line_size, block);
3855 * cleans dc, ac, coded_block for the current non intra MB
3857 void ff_clean_intra_table_entries(MpegEncContext *s)
3859 int wrap = s->b8_stride;
3860 int xy = s->block_index[0];
3863 s->dc_val[0][xy + 1 ] =
3864 s->dc_val[0][xy + wrap] =
3865 s->dc_val[0][xy + 1 + wrap] = 1024;
3867 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3868 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3869 if (s->msmpeg4_version>=3) {
3870 s->coded_block[xy ] =
3871 s->coded_block[xy + 1 ] =
3872 s->coded_block[xy + wrap] =
3873 s->coded_block[xy + 1 + wrap] = 0;
3876 wrap = s->mb_stride;
3877 xy = s->mb_x + s->mb_y * wrap;
3879 s->dc_val[2][xy] = 1024;
3881 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3882 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3884 s->mbintra_table[xy]= 0;
3887 /* generic function called after a macroblock has been parsed by the
3888 decoder or after it has been encoded by the encoder.
3890 Important variables used:
3891 s->mb_intra : true if intra macroblock
3892 s->mv_dir : motion vector direction
3893 s->mv_type : motion vector type
3894 s->mv : motion vector
3895 s->interlaced_dct : true if interlaced dct used (mpeg2)
3897 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3900 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3902 if(s->avctx->xvmc_acceleration){
3903 XVMC_decode_mb(s);//xvmc uses pblocks
3911 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3912 /* save DCT coefficients */
3914 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3917 *dct++ = block[i][s->dsp.idct_permutation[j]];
3920 s->current_picture.qscale_table[mb_xy]= s->qscale;
3922 /* update DC predictors for P macroblocks */
3924 if (s->h263_pred || s->h263_aic) {
3925 if(s->mbintra_table[mb_xy])
3926 ff_clean_intra_table_entries(s);
3930 s->last_dc[2] = 128 << s->intra_dc_precision;
3933 else if (s->h263_pred || s->h263_aic)
3934 s->mbintra_table[mb_xy]=1;
3936 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
3937 uint8_t *dest_y, *dest_cb, *dest_cr;
3938 int dct_linesize, dct_offset;
3939 op_pixels_func (*op_pix)[4];
3940 qpel_mc_func (*op_qpix)[16];
3941 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3942 const int uvlinesize= s->current_picture.linesize[1];
3943 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3944 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3946 /* avoid copy if macroblock skipped in last frame too */
3947 /* skip only during decoding as we might trash the buffers during encoding a bit */
3949 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3950 const int age= s->current_picture.age;
3954 if (s->mb_skipped) {
3956 assert(s->pict_type!=I_TYPE);
3958 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3959 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3961 /* if previous was skipped too, then nothing to do ! */
3962 if (*mbskip_ptr >= age && s->current_picture.reference){
3965 } else if(!s->current_picture.reference){
3966 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3967 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3969 *mbskip_ptr = 0; /* not skipped */
3973 dct_linesize = linesize << s->interlaced_dct;
3974 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3978 dest_cb= s->dest[1];
3979 dest_cr= s->dest[2];
3981 dest_y = s->b_scratchpad;
3982 dest_cb= s->b_scratchpad+16*linesize;
3983 dest_cr= s->b_scratchpad+32*linesize;
3987 /* motion handling */
3988 /* decoding or more than one mb_type (MC was already done otherwise) */
3991 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3993 if (s->mv_dir & MV_DIR_FORWARD) {
3994 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3995 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3997 if (s->mv_dir & MV_DIR_BACKWARD) {
3998 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
4001 op_qpix= s->me.qpel_put;
4002 if ((!s->no_rounding) || s->pict_type==B_TYPE){
4003 op_pix = s->dsp.put_pixels_tab;
4005 op_pix = s->dsp.put_no_rnd_pixels_tab;
4007 if (s->mv_dir & MV_DIR_FORWARD) {
4008 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4009 op_pix = s->dsp.avg_pixels_tab;
4010 op_qpix= s->me.qpel_avg;
4012 if (s->mv_dir & MV_DIR_BACKWARD) {
4013 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4018 /* skip dequant / idct if we are really late ;) */
4019 if(s->hurry_up>1) goto skip_idct;
4020 if(s->avctx->skip_idct){
4021 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
4022 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
4023 || s->avctx->skip_idct >= AVDISCARD_ALL)
4027 /* add dct residue */
4028 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
4029 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
4030 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4031 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4032 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4033 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4035 if(!(s->flags&CODEC_FLAG_GRAY)){
4036 if (s->chroma_y_shift){
4037 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4038 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4042 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4043 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4044 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4045 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4048 } else if(s->codec_id != CODEC_ID_WMV2){
4049 add_dct(s, block[0], 0, dest_y , dct_linesize);
4050 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
4051 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
4052 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
4054 if(!(s->flags&CODEC_FLAG_GRAY)){
4055 if(s->chroma_y_shift){//Chroma420
4056 add_dct(s, block[4], 4, dest_cb, uvlinesize);
4057 add_dct(s, block[5], 5, dest_cr, uvlinesize);
4060 dct_linesize = uvlinesize << s->interlaced_dct;
4061 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4063 add_dct(s, block[4], 4, dest_cb, dct_linesize);
4064 add_dct(s, block[5], 5, dest_cr, dct_linesize);
4065 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4066 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4067 if(!s->chroma_x_shift){//Chroma444
4068 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4069 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4070 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4071 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4077 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4080 /* dct only in intra block */
4081 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4082 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4083 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4084 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4085 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4087 if(!(s->flags&CODEC_FLAG_GRAY)){
4088 if(s->chroma_y_shift){
4089 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4090 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4094 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4095 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4096 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4097 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4101 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
4102 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
4103 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
4104 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4106 if(!(s->flags&CODEC_FLAG_GRAY)){
4107 if(s->chroma_y_shift){
4108 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4109 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4112 dct_linesize = uvlinesize << s->interlaced_dct;
4113 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4115 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4116 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4117 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4118 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4119 if(!s->chroma_x_shift){//Chroma444
4120 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4121 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4122 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4123 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4131 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4132 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4133 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4138 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4139 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4140 else MPV_decode_mb_internal(s, block, 0);
4143 #ifdef CONFIG_ENCODERS
4145 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4147 static const char tab[64]=
4159 DCTELEM *block= s->block[n];
4160 const int last_index= s->block_last_index[n];
4165 threshold= -threshold;
4169 /* are all which we could set to zero are allready zero? */
4170 if(last_index<=skip_dc - 1) return;
4172 for(i=0; i<=last_index; i++){
4173 const int j = s->intra_scantable.permutated[i];
4174 const int level = FFABS(block[j]);
4176 if(skip_dc && i==0) continue;
4185 if(score >= threshold) return;
4186 for(i=skip_dc; i<=last_index; i++){
4187 const int j = s->intra_scantable.permutated[i];
4190 if(block[0]) s->block_last_index[n]= 0;
4191 else s->block_last_index[n]= -1;
4194 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4197 const int maxlevel= s->max_qcoeff;
4198 const int minlevel= s->min_qcoeff;
4202 i=1; //skip clipping of intra dc
4206 for(;i<=last_index; i++){
4207 const int j= s->intra_scantable.permutated[i];
4208 int level = block[j];
4210 if (level>maxlevel){
4213 }else if(level<minlevel){
4221 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4222 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4225 #endif //CONFIG_ENCODERS
4229 * @param h is the normal height, this will be reduced automatically if needed for the last row
4231 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4232 if (s->avctx->draw_horiz_band) {
4236 if(s->picture_structure != PICT_FRAME){
4239 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4242 h= FFMIN(h, s->avctx->height - y);
4244 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4245 src= (AVFrame*)s->current_picture_ptr;
4246 else if(s->last_picture_ptr)
4247 src= (AVFrame*)s->last_picture_ptr;
4251 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4257 offset[0]= y * s->linesize;;
4259 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4265 s->avctx->draw_horiz_band(s->avctx, src, offset,
4266 y, s->picture_structure, h);
4270 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4271 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4272 const int uvlinesize= s->current_picture.linesize[1];
4273 const int mb_size= 4 - s->avctx->lowres;
4275 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4276 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4277 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4278 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4279 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4280 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;
4281 //block_index is not used by mpeg2, so it is not affected by chroma_format
4283 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4284 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4285 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4287 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4289 s->dest[0] += s->mb_y * linesize << mb_size;
4290 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4291 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4295 #ifdef CONFIG_ENCODERS
4297 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4307 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4308 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4309 int v= ptr[x2 + y2*stride];
4315 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4320 static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4322 int16_t weight[8][64];
4323 DCTELEM orig[8][64];
4324 const int mb_x= s->mb_x;
4325 const int mb_y= s->mb_y;
4328 int dct_offset = s->linesize*8; //default for progressive frames
4329 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4332 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct;
4334 if(s->adaptive_quant){
4335 const int last_qp= s->qscale;
4336 const int mb_xy= mb_x + mb_y*s->mb_stride;
4338 s->lambda= s->lambda_table[mb_xy];
4341 if(!(s->flags&CODEC_FLAG_QP_RD)){
4342 s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
4343 s->dquant= s->qscale - last_qp;
4345 if(s->out_format==FMT_H263){
4346 s->dquant= av_clip(s->dquant, -2, 2);
4348 if(s->codec_id==CODEC_ID_MPEG4){
4350 if(s->pict_type == B_TYPE){
4351 if(s->dquant&1 || s->mv_dir&MV_DIRECT)
4354 if(s->mv_type==MV_TYPE_8X8)
4360 ff_set_qscale(s, last_qp + s->dquant);
4361 }else if(s->flags&CODEC_FLAG_QP_RD)
4362 ff_set_qscale(s, s->qscale + s->dquant);
4364 wrap_y = s->linesize;
4365 wrap_c = s->uvlinesize;
4366 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4367 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4368 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4370 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4371 uint8_t *ebuf= s->edge_emu_buffer + 32;
4372 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
4374 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);
4375 ptr_cb= ebuf+18*wrap_y;
4376 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);
4377 ptr_cr= ebuf+18*wrap_y+8;
4381 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4382 int progressive_score, interlaced_score;
4384 s->interlaced_dct=0;
4385 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4386 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4388 if(progressive_score > 0){
4389 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4390 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4391 if(progressive_score > interlaced_score){
4392 s->interlaced_dct=1;
4396 if (s->chroma_format == CHROMA_422)
4402 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4403 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4404 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4405 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4407 if(s->flags&CODEC_FLAG_GRAY){
4411 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4412 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4413 if(!s->chroma_y_shift){ /* 422 */
4414 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4415 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4419 op_pixels_func (*op_pix)[4];
4420 qpel_mc_func (*op_qpix)[16];
4421 uint8_t *dest_y, *dest_cb, *dest_cr;
4423 dest_y = s->dest[0];
4424 dest_cb = s->dest[1];
4425 dest_cr = s->dest[2];
4427 if ((!s->no_rounding) || s->pict_type==B_TYPE){
4428 op_pix = s->dsp.put_pixels_tab;
4429 op_qpix= s->dsp.put_qpel_pixels_tab;
4431 op_pix = s->dsp.put_no_rnd_pixels_tab;
4432 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4435 if (s->mv_dir & MV_DIR_FORWARD) {
4436 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4437 op_pix = s->dsp.avg_pixels_tab;
4438 op_qpix= s->dsp.avg_qpel_pixels_tab;
4440 if (s->mv_dir & MV_DIR_BACKWARD) {
4441 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4444 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4445 int progressive_score, interlaced_score;
4447 s->interlaced_dct=0;
4448 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4449 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4451 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4453 if(progressive_score>0){
4454 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4455 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4457 if(progressive_score > interlaced_score){
4458 s->interlaced_dct=1;
4462 if (s->chroma_format == CHROMA_422)
4468 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4469 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4470 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4471 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4473 if(s->flags&CODEC_FLAG_GRAY){
4477 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4478 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4479 if(!s->chroma_y_shift){ /* 422 */
4480 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4481 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4484 /* pre quantization */
4485 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4487 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4488 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4489 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4490 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;
4491 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4492 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4493 if(!s->chroma_y_shift){ /* 422 */
4494 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;
4495 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;
4500 if(s->avctx->quantizer_noise_shaping){
4501 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4502 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4503 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4504 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4505 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4506 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4507 if(!s->chroma_y_shift){ /* 422 */
4508 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4509 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4511 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4514 /* DCT & quantize */
4515 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4517 for(i=0;i<mb_block_count;i++) {
4520 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4521 // FIXME we could decide to change to quantizer instead of clipping
4522 // JS: I don't think that would be a good idea it could lower quality instead
4523 // of improve it. Just INTRADC clipping deserves changes in quantizer
4524 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4526 s->block_last_index[i]= -1;
4528 if(s->avctx->quantizer_noise_shaping){
4529 for(i=0;i<mb_block_count;i++) {
4531 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4536 if(s->luma_elim_threshold && !s->mb_intra)
4538 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4539 if(s->chroma_elim_threshold && !s->mb_intra)
4540 for(i=4; i<mb_block_count; i++)
4541 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4543 if(s->flags & CODEC_FLAG_CBP_RD){
4544 for(i=0;i<mb_block_count;i++) {
4545 if(s->block_last_index[i] == -1)
4546 s->coded_score[i]= INT_MAX/256;
4551 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4552 s->block_last_index[4]=
4553 s->block_last_index[5]= 0;
4555 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4558 //non c quantize code returns incorrect block_last_index FIXME
4559 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4560 for(i=0; i<mb_block_count; i++){
4562 if(s->block_last_index[i]>0){
4563 for(j=63; j>0; j--){
4564 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4566 s->block_last_index[i]= j;
4571 /* huffman encode */
4572 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4573 case CODEC_ID_MPEG1VIDEO:
4574 case CODEC_ID_MPEG2VIDEO:
4575 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4576 case CODEC_ID_MPEG4:
4577 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4578 case CODEC_ID_MSMPEG4V2:
4579 case CODEC_ID_MSMPEG4V3:
4581 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4583 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4584 #ifdef CONFIG_H261_ENCODER
4586 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4589 case CODEC_ID_H263P:
4593 h263_encode_mb(s, s->block, motion_x, motion_y); break;
4594 case CODEC_ID_MJPEG:
4595 mjpeg_encode_mb(s, s->block); break;
4601 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4603 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
4604 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
4607 #endif //CONFIG_ENCODERS
4609 void ff_mpeg_flush(AVCodecContext *avctx){
4611 MpegEncContext *s = avctx->priv_data;
4613 if(s==NULL || s->picture==NULL)
4616 for(i=0; i<MAX_PICTURE_COUNT; i++){
4617 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4618 || s->picture[i].type == FF_BUFFER_TYPE_USER))
4619 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4621 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4623 s->mb_x= s->mb_y= 0;
4625 s->parse_context.state= -1;
4626 s->parse_context.frame_start_found= 0;
4627 s->parse_context.overread= 0;
4628 s->parse_context.overread_index= 0;
4629 s->parse_context.index= 0;
4630 s->parse_context.last_index= 0;
4631 s->bitstream_buffer_size=0;
4635 #ifdef CONFIG_ENCODERS
4636 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4638 const uint16_t *srcw= (uint16_t*)src;
4639 int words= length>>4;
4640 int bits= length&15;
4643 if(length==0) return;
4646 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4647 }else if(put_bits_count(pb)&7){
4648 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4650 for(i=0; put_bits_count(pb)&31; i++)
4651 put_bits(pb, 8, src[i]);
4653 memcpy(pbBufPtr(pb), src+i, 2*words-i);
4654 skip_put_bytes(pb, 2*words-i);
4657 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4660 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4663 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4666 d->mb_skip_run= s->mb_skip_run;
4668 d->last_dc[i]= s->last_dc[i];
4671 d->mv_bits= s->mv_bits;
4672 d->i_tex_bits= s->i_tex_bits;
4673 d->p_tex_bits= s->p_tex_bits;
4674 d->i_count= s->i_count;
4675 d->f_count= s->f_count;
4676 d->b_count= s->b_count;
4677 d->skip_count= s->skip_count;
4678 d->misc_bits= s->misc_bits;
4682 d->qscale= s->qscale;
4683 d->dquant= s->dquant;
4686 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4689 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4690 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4693 d->mb_skip_run= s->mb_skip_run;
4695 d->last_dc[i]= s->last_dc[i];
4698 d->mv_bits= s->mv_bits;
4699 d->i_tex_bits= s->i_tex_bits;
4700 d->p_tex_bits= s->p_tex_bits;
4701 d->i_count= s->i_count;
4702 d->f_count= s->f_count;
4703 d->b_count= s->b_count;
4704 d->skip_count= s->skip_count;
4705 d->misc_bits= s->misc_bits;
4707 d->mb_intra= s->mb_intra;
4708 d->mb_skipped= s->mb_skipped;
4709 d->mv_type= s->mv_type;
4710 d->mv_dir= s->mv_dir;
4712 if(s->data_partitioning){
4714 d->tex_pb= s->tex_pb;
4718 d->block_last_index[i]= s->block_last_index[i];
4719 d->interlaced_dct= s->interlaced_dct;
4720 d->qscale= s->qscale;
4723 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4724 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4725 int *dmin, int *next_block, int motion_x, int motion_y)
4728 uint8_t *dest_backup[3];
4730 copy_context_before_encode(s, backup, type);
4732 s->block= s->blocks[*next_block];
4733 s->pb= pb[*next_block];
4734 if(s->data_partitioning){
4735 s->pb2 = pb2 [*next_block];
4736 s->tex_pb= tex_pb[*next_block];
4740 memcpy(dest_backup, s->dest, sizeof(s->dest));
4741 s->dest[0] = s->rd_scratchpad;
4742 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4743 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4744 assert(s->linesize >= 32); //FIXME
4747 encode_mb(s, motion_x, motion_y);
4749 score= put_bits_count(&s->pb);
4750 if(s->data_partitioning){
4751 score+= put_bits_count(&s->pb2);
4752 score+= put_bits_count(&s->tex_pb);
4755 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4756 MPV_decode_mb(s, s->block);
4758 score *= s->lambda2;
4759 score += sse_mb(s) << FF_LAMBDA_SHIFT;
4763 memcpy(s->dest, dest_backup, sizeof(s->dest));
4770 copy_context_after_encode(best, s, type);
4774 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4775 uint32_t *sq = ff_squareTbl + 256;
4780 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4781 else if(w==8 && h==8)
4782 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4786 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4795 static int sse_mb(MpegEncContext *s){
4799 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4800 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4803 if(s->avctx->mb_cmp == FF_CMP_NSSE){
4804 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)
4805 +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)
4806 +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);
4808 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)
4809 +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)
4810 +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);
4813 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)
4814 +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)
4815 +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);
4818 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4819 MpegEncContext *s= arg;
4823 s->me.dia_size= s->avctx->pre_dia_size;
4824 s->first_slice_line=1;
4825 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4826 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4827 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4829 s->first_slice_line=0;
4837 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4838 MpegEncContext *s= arg;
4840 ff_check_alignment();
4842 s->me.dia_size= s->avctx->dia_size;
4843 s->first_slice_line=1;
4844 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4845 s->mb_x=0; //for block init below
4846 ff_init_block_index(s);
4847 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4848 s->block_index[0]+=2;
4849 s->block_index[1]+=2;
4850 s->block_index[2]+=2;
4851 s->block_index[3]+=2;
4853 /* compute motion vector & mb_type and store in context */
4854 if(s->pict_type==B_TYPE)
4855 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4857 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4859 s->first_slice_line=0;
4864 static int mb_var_thread(AVCodecContext *c, void *arg){
4865 MpegEncContext *s= arg;
4868 ff_check_alignment();
4870 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4871 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4874 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4876 int sum = s->dsp.pix_sum(pix, s->linesize);
4878 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4880 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4881 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4882 s->me.mb_var_sum_temp += varc;
4888 static void write_slice_end(MpegEncContext *s){
4889 if(s->codec_id==CODEC_ID_MPEG4){
4890 if(s->partitioned_frame){
4891 ff_mpeg4_merge_partitions(s);
4894 ff_mpeg4_stuffing(&s->pb);
4895 }else if(s->out_format == FMT_MJPEG){
4896 ff_mjpeg_stuffing(&s->pb);
4899 align_put_bits(&s->pb);
4900 flush_put_bits(&s->pb);
4902 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4903 s->misc_bits+= get_bits_diff(s);
4906 static int encode_thread(AVCodecContext *c, void *arg){
4907 MpegEncContext *s= arg;
4908 int mb_x, mb_y, pdif = 0;
4910 MpegEncContext best_s, backup_s;
4911 uint8_t bit_buf[2][MAX_MB_BYTES];
4912 uint8_t bit_buf2[2][MAX_MB_BYTES];
4913 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4914 PutBitContext pb[2], pb2[2], tex_pb[2];
4915 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4917 ff_check_alignment();
4920 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4921 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4922 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4925 s->last_bits= put_bits_count(&s->pb);
4936 /* init last dc values */
4937 /* note: quant matrix value (8) is implied here */
4938 s->last_dc[i] = 128 << s->intra_dc_precision;
4940 s->current_picture.error[i] = 0;
4943 memset(s->last_mv, 0, sizeof(s->last_mv));
4947 switch(s->codec_id){
4949 case CODEC_ID_H263P:
4951 s->gob_index = ff_h263_get_gob_height(s);
4953 case CODEC_ID_MPEG4:
4954 if(s->partitioned_frame)
4955 ff_mpeg4_init_partitions(s);
4961 s->first_slice_line = 1;
4962 s->ptr_lastgob = s->pb.buf;
4963 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4964 // printf("row %d at %X\n", s->mb_y, (int)s);
4968 ff_set_qscale(s, s->qscale);
4969 ff_init_block_index(s);
4971 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4972 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4973 int mb_type= s->mb_type[xy];
4978 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4979 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4982 if(s->data_partitioning){
4983 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4984 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4985 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4991 s->mb_y = mb_y; // moved into loop, can get changed by H.261
4992 ff_update_block_index(s);
4994 #ifdef CONFIG_H261_ENCODER
4995 if(s->codec_id == CODEC_ID_H261){
4996 ff_h261_reorder_mb_index(s);
4997 xy= s->mb_y*s->mb_stride + s->mb_x;
4998 mb_type= s->mb_type[xy];
5002 /* write gob / video packet header */
5004 int current_packet_size, is_gob_start;
5006 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
5008 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
5010 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
5012 switch(s->codec_id){
5014 case CODEC_ID_H263P:
5015 if(!s->h263_slice_structured)
5016 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
5018 case CODEC_ID_MPEG2VIDEO:
5019 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
5020 case CODEC_ID_MPEG1VIDEO:
5021 if(s->mb_skip_run) is_gob_start=0;
5026 if(s->start_mb_y != mb_y || mb_x!=0){
5029 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
5030 ff_mpeg4_init_partitions(s);
5034 assert((put_bits_count(&s->pb)&7) == 0);
5035 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
5037 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
5038 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
5039 int d= 100 / s->avctx->error_rate;
5041 current_packet_size=0;
5042 #ifndef ALT_BITSTREAM_WRITER
5043 s->pb.buf_ptr= s->ptr_lastgob;
5045 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
5049 if (s->avctx->rtp_callback){
5050 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
5051 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
5054 switch(s->codec_id){
5055 case CODEC_ID_MPEG4:
5056 ff_mpeg4_encode_video_packet_header(s);
5057 ff_mpeg4_clean_buffers(s);
5059 case CODEC_ID_MPEG1VIDEO:
5060 case CODEC_ID_MPEG2VIDEO:
5061 ff_mpeg1_encode_slice_header(s);
5062 ff_mpeg1_clean_buffers(s);
5065 case CODEC_ID_H263P:
5066 h263_encode_gob_header(s, mb_y);
5070 if(s->flags&CODEC_FLAG_PASS1){
5071 int bits= put_bits_count(&s->pb);
5072 s->misc_bits+= bits - s->last_bits;
5076 s->ptr_lastgob += current_packet_size;
5077 s->first_slice_line=1;
5078 s->resync_mb_x=mb_x;
5079 s->resync_mb_y=mb_y;
5083 if( (s->resync_mb_x == s->mb_x)
5084 && s->resync_mb_y+1 == s->mb_y){
5085 s->first_slice_line=0;
5089 s->dquant=0; //only for QP_RD
5091 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5093 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5095 copy_context_before_encode(&backup_s, s, -1);
5097 best_s.data_partitioning= s->data_partitioning;
5098 best_s.partitioned_frame= s->partitioned_frame;
5099 if(s->data_partitioning){
5100 backup_s.pb2= s->pb2;
5101 backup_s.tex_pb= s->tex_pb;
5104 if(mb_type&CANDIDATE_MB_TYPE_INTER){
5105 s->mv_dir = MV_DIR_FORWARD;
5106 s->mv_type = MV_TYPE_16X16;
5108 s->mv[0][0][0] = s->p_mv_table[xy][0];
5109 s->mv[0][0][1] = s->p_mv_table[xy][1];
5110 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5111 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5113 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5114 s->mv_dir = MV_DIR_FORWARD;
5115 s->mv_type = MV_TYPE_FIELD;
5118 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5119 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5120 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5122 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5123 &dmin, &next_block, 0, 0);
5125 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5126 s->mv_dir = MV_DIR_FORWARD;
5127 s->mv_type = MV_TYPE_16X16;
5131 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5132 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5134 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5135 s->mv_dir = MV_DIR_FORWARD;
5136 s->mv_type = MV_TYPE_8X8;
5139 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5140 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5142 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5143 &dmin, &next_block, 0, 0);
5145 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5146 s->mv_dir = MV_DIR_FORWARD;
5147 s->mv_type = MV_TYPE_16X16;
5149 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5150 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5151 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5152 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5154 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5155 s->mv_dir = MV_DIR_BACKWARD;
5156 s->mv_type = MV_TYPE_16X16;
5158 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5159 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5160 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5161 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5163 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5164 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5165 s->mv_type = MV_TYPE_16X16;
5167 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5168 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5169 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5170 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5171 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5172 &dmin, &next_block, 0, 0);
5174 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5175 s->mv_dir = MV_DIR_FORWARD;
5176 s->mv_type = MV_TYPE_FIELD;
5179 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5180 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5181 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5183 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5184 &dmin, &next_block, 0, 0);
5186 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5187 s->mv_dir = MV_DIR_BACKWARD;
5188 s->mv_type = MV_TYPE_FIELD;
5191 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5192 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5193 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5195 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5196 &dmin, &next_block, 0, 0);
5198 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5199 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5200 s->mv_type = MV_TYPE_FIELD;
5202 for(dir=0; dir<2; dir++){
5204 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5205 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5206 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5209 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5210 &dmin, &next_block, 0, 0);
5212 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5214 s->mv_type = MV_TYPE_16X16;
5218 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5219 &dmin, &next_block, 0, 0);
5220 if(s->h263_pred || s->h263_aic){
5222 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5224 ff_clean_intra_table_entries(s); //old mode?
5228 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
5229 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
5230 const int last_qp= backup_s.qscale;
5233 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5234 static const int dquant_tab[4]={-1,1,-2,2};
5236 assert(backup_s.dquant == 0);
5239 s->mv_dir= best_s.mv_dir;
5240 s->mv_type = MV_TYPE_16X16;
5241 s->mb_intra= best_s.mb_intra;
5242 s->mv[0][0][0] = best_s.mv[0][0][0];
5243 s->mv[0][0][1] = best_s.mv[0][0][1];
5244 s->mv[1][0][0] = best_s.mv[1][0][0];
5245 s->mv[1][0][1] = best_s.mv[1][0][1];
5247 qpi = s->pict_type == B_TYPE ? 2 : 0;
5248 for(; qpi<4; qpi++){
5249 int dquant= dquant_tab[qpi];
5250 qp= last_qp + dquant;
5251 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5253 backup_s.dquant= dquant;
5254 if(s->mb_intra && s->dc_val[0]){
5256 dc[i]= s->dc_val[0][ s->block_index[i] ];
5257 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5261 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5262 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5263 if(best_s.qscale != qp){
5264 if(s->mb_intra && s->dc_val[0]){
5266 s->dc_val[0][ s->block_index[i] ]= dc[i];
5267 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5274 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5275 int mx= s->b_direct_mv_table[xy][0];
5276 int my= s->b_direct_mv_table[xy][1];
5278 backup_s.dquant = 0;
5279 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5281 ff_mpeg4_set_direct_mv(s, mx, my);
5282 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5283 &dmin, &next_block, mx, my);
5285 if(mb_type&CANDIDATE_MB_TYPE_DIRECT0){
5286 backup_s.dquant = 0;
5287 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5289 ff_mpeg4_set_direct_mv(s, 0, 0);
5290 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5291 &dmin, &next_block, 0, 0);
5293 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
5296 coded |= s->block_last_index[i];
5299 memcpy(s->mv, best_s.mv, sizeof(s->mv));
5300 if(best_s.mv_dir & MV_DIRECT){
5301 mx=my=0; //FIXME find the one we actually used
5302 ff_mpeg4_set_direct_mv(s, mx, my);
5303 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
5311 s->mv_dir= best_s.mv_dir;
5312 s->mv_type = best_s.mv_type;
5314 /* s->mv[0][0][0] = best_s.mv[0][0][0];
5315 s->mv[0][0][1] = best_s.mv[0][0][1];
5316 s->mv[1][0][0] = best_s.mv[1][0][0];
5317 s->mv[1][0][1] = best_s.mv[1][0][1];*/
5320 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5321 &dmin, &next_block, mx, my);
5326 s->current_picture.qscale_table[xy]= best_s.qscale;
5328 copy_context_after_encode(s, &best_s, -1);
5330 pb_bits_count= put_bits_count(&s->pb);
5331 flush_put_bits(&s->pb);
5332 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5335 if(s->data_partitioning){
5336 pb2_bits_count= put_bits_count(&s->pb2);
5337 flush_put_bits(&s->pb2);
5338 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5339 s->pb2= backup_s.pb2;
5341 tex_pb_bits_count= put_bits_count(&s->tex_pb);
5342 flush_put_bits(&s->tex_pb);
5343 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5344 s->tex_pb= backup_s.tex_pb;
5346 s->last_bits= put_bits_count(&s->pb);
5348 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5349 ff_h263_update_motion_val(s);
5351 if(next_block==0){ //FIXME 16 vs linesize16
5352 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5353 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5354 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5357 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5358 MPV_decode_mb(s, s->block);
5360 int motion_x = 0, motion_y = 0;
5361 s->mv_type=MV_TYPE_16X16;
5362 // only one MB-Type possible
5365 case CANDIDATE_MB_TYPE_INTRA:
5368 motion_x= s->mv[0][0][0] = 0;
5369 motion_y= s->mv[0][0][1] = 0;
5371 case CANDIDATE_MB_TYPE_INTER:
5372 s->mv_dir = MV_DIR_FORWARD;
5374 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5375 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5377 case CANDIDATE_MB_TYPE_INTER_I:
5378 s->mv_dir = MV_DIR_FORWARD;
5379 s->mv_type = MV_TYPE_FIELD;
5382 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5383 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5384 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5387 case CANDIDATE_MB_TYPE_INTER4V:
5388 s->mv_dir = MV_DIR_FORWARD;
5389 s->mv_type = MV_TYPE_8X8;
5392 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5393 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5396 case CANDIDATE_MB_TYPE_DIRECT:
5397 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5399 motion_x=s->b_direct_mv_table[xy][0];
5400 motion_y=s->b_direct_mv_table[xy][1];
5401 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5403 case CANDIDATE_MB_TYPE_DIRECT0:
5404 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5406 ff_mpeg4_set_direct_mv(s, 0, 0);
5408 case CANDIDATE_MB_TYPE_BIDIR:
5409 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5411 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5412 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5413 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5414 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5416 case CANDIDATE_MB_TYPE_BACKWARD:
5417 s->mv_dir = MV_DIR_BACKWARD;
5419 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5420 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5422 case CANDIDATE_MB_TYPE_FORWARD:
5423 s->mv_dir = MV_DIR_FORWARD;
5425 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5426 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5427 // printf(" %d %d ", motion_x, motion_y);
5429 case CANDIDATE_MB_TYPE_FORWARD_I:
5430 s->mv_dir = MV_DIR_FORWARD;
5431 s->mv_type = MV_TYPE_FIELD;
5434 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5435 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5436 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5439 case CANDIDATE_MB_TYPE_BACKWARD_I:
5440 s->mv_dir = MV_DIR_BACKWARD;
5441 s->mv_type = MV_TYPE_FIELD;
5444 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5445 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5446 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5449 case CANDIDATE_MB_TYPE_BIDIR_I:
5450 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5451 s->mv_type = MV_TYPE_FIELD;
5453 for(dir=0; dir<2; dir++){
5455 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5456 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5457 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5462 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5465 encode_mb(s, motion_x, motion_y);
5467 // RAL: Update last macroblock type
5468 s->last_mv_dir = s->mv_dir;
5470 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5471 ff_h263_update_motion_val(s);
5473 MPV_decode_mb(s, s->block);
5476 /* clean the MV table in IPS frames for direct mode in B frames */
5477 if(s->mb_intra /* && I,P,S_TYPE */){
5478 s->p_mv_table[xy][0]=0;
5479 s->p_mv_table[xy][1]=0;
5482 if(s->flags&CODEC_FLAG_PSNR){
5486 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
5487 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
5489 s->current_picture.error[0] += sse(
5490 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
5491 s->dest[0], w, h, s->linesize);
5492 s->current_picture.error[1] += sse(
5493 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5494 s->dest[1], w>>1, h>>1, s->uvlinesize);
5495 s->current_picture.error[2] += sse(
5496 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5497 s->dest[2], w>>1, h>>1, s->uvlinesize);
5500 if(s->out_format == FMT_H263)
5501 ff_h263_loop_filter(s);
5503 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5507 //not beautiful here but we must write it before flushing so it has to be here
5508 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5509 msmpeg4_encode_ext_header(s);
5513 /* Send the last GOB if RTP */
5514 if (s->avctx->rtp_callback) {
5515 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5516 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5517 /* Call the RTP callback to send the last GOB */
5519 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5525 #define MERGE(field) dst->field += src->field; src->field=0
5526 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5527 MERGE(me.scene_change_score);
5528 MERGE(me.mc_mb_var_sum_temp);
5529 MERGE(me.mb_var_sum_temp);
5532 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
5535 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5536 MERGE(dct_count[1]);
5546 MERGE(padding_bug_score);
5547 MERGE(current_picture.error[0]);
5548 MERGE(current_picture.error[1]);
5549 MERGE(current_picture.error[2]);
5551 if(dst->avctx->noise_reduction){
5552 for(i=0; i<64; i++){
5553 MERGE(dct_error_sum[0][i]);
5554 MERGE(dct_error_sum[1][i]);
5558 assert(put_bits_count(&src->pb) % 8 ==0);
5559 assert(put_bits_count(&dst->pb) % 8 ==0);
5560 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5561 flush_put_bits(&dst->pb);
5564 static int estimate_qp(MpegEncContext *s, int dry_run){
5565 if (s->next_lambda){
5566 s->current_picture_ptr->quality=
5567 s->current_picture.quality = s->next_lambda;
5568 if(!dry_run) s->next_lambda= 0;
5569 } else if (!s->fixed_qscale) {
5570 s->current_picture_ptr->quality=
5571 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5572 if (s->current_picture.quality < 0)
5576 if(s->adaptive_quant){
5577 switch(s->codec_id){
5578 case CODEC_ID_MPEG4:
5579 ff_clean_mpeg4_qscales(s);
5582 case CODEC_ID_H263P:
5584 ff_clean_h263_qscales(s);
5588 s->lambda= s->lambda_table[0];
5591 s->lambda= s->current_picture.quality;
5592 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5597 static int encode_picture(MpegEncContext *s, int picture_number)
5602 s->picture_number = picture_number;
5604 /* Reset the average MB variance */
5605 s->me.mb_var_sum_temp =
5606 s->me.mc_mb_var_sum_temp = 0;
5608 /* we need to initialize some time vars before we can encode b-frames */
5609 // RAL: Condition added for MPEG1VIDEO
5610 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5611 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5613 s->me.scene_change_score=0;
5615 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5617 if(s->pict_type==I_TYPE){
5618 if(s->msmpeg4_version >= 3) s->no_rounding=1;
5619 else s->no_rounding=0;
5620 }else if(s->pict_type!=B_TYPE){
5621 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5622 s->no_rounding ^= 1;
5625 if(s->flags & CODEC_FLAG_PASS2){
5626 if (estimate_qp(s,1) < 0)
5628 ff_get_2pass_fcode(s);
5629 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5630 if(s->pict_type==B_TYPE)
5631 s->lambda= s->last_lambda_for[s->pict_type];
5633 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5637 s->mb_intra=0; //for the rate distortion & bit compare functions
5638 for(i=1; i<s->avctx->thread_count; i++){
5639 ff_update_duplicate_context(s->thread_context[i], s);
5644 /* Estimate motion for every MB */
5645 if(s->pict_type != I_TYPE){
5646 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5647 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
5648 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5649 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
5650 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5654 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5655 }else /* if(s->pict_type == I_TYPE) */{
5657 for(i=0; i<s->mb_stride*s->mb_height; i++)
5658 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5660 if(!s->fixed_qscale){
5661 /* finding spatial complexity for I-frame rate control */
5662 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5665 for(i=1; i<s->avctx->thread_count; i++){
5666 merge_context_after_me(s, s->thread_context[i]);
5668 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5669 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5672 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5673 s->pict_type= I_TYPE;
5674 for(i=0; i<s->mb_stride*s->mb_height; i++)
5675 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5676 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5680 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5681 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5683 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5685 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5686 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5687 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5690 ff_fix_long_p_mvs(s);
5691 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5692 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5696 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5697 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5702 if(s->pict_type==B_TYPE){
5705 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5706 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5707 s->f_code = FFMAX(a, b);
5709 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5710 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5711 s->b_code = FFMAX(a, b);
5713 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5714 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5715 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5716 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5717 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5719 for(dir=0; dir<2; dir++){
5722 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5723 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5724 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5725 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5733 if (estimate_qp(s, 0) < 0)
5736 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5737 s->qscale= 3; //reduce clipping problems
5739 if (s->out_format == FMT_MJPEG) {
5740 /* for mjpeg, we do include qscale in the matrix */
5741 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5743 int j= s->dsp.idct_permutation[i];
5745 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5747 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5748 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5752 //FIXME var duplication
5753 s->current_picture_ptr->key_frame=
5754 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5755 s->current_picture_ptr->pict_type=
5756 s->current_picture.pict_type= s->pict_type;
5758 if(s->current_picture.key_frame)
5759 s->picture_in_gop_number=0;
5761 s->last_bits= put_bits_count(&s->pb);
5762 switch(s->out_format) {
5764 mjpeg_picture_header(s);
5766 #ifdef CONFIG_H261_ENCODER
5768 ff_h261_encode_picture_header(s, picture_number);
5772 if (s->codec_id == CODEC_ID_WMV2)
5773 ff_wmv2_encode_picture_header(s, picture_number);
5774 else if (s->h263_msmpeg4)
5775 msmpeg4_encode_picture_header(s, picture_number);
5776 else if (s->h263_pred)
5777 mpeg4_encode_picture_header(s, picture_number);
5778 #ifdef CONFIG_RV10_ENCODER
5779 else if (s->codec_id == CODEC_ID_RV10)
5780 rv10_encode_picture_header(s, picture_number);
5782 #ifdef CONFIG_RV20_ENCODER
5783 else if (s->codec_id == CODEC_ID_RV20)
5784 rv20_encode_picture_header(s, picture_number);
5786 else if (s->codec_id == CODEC_ID_FLV1)
5787 ff_flv_encode_picture_header(s, picture_number);
5789 h263_encode_picture_header(s, picture_number);
5792 mpeg1_encode_picture_header(s, picture_number);
5799 bits= put_bits_count(&s->pb);
5800 s->header_bits= bits - s->last_bits;
5802 for(i=1; i<s->avctx->thread_count; i++){
5803 update_duplicate_context_after_me(s->thread_context[i], s);
5805 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5806 for(i=1; i<s->avctx->thread_count; i++){
5807 merge_context_after_encode(s, s->thread_context[i]);
5813 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5814 const int intra= s->mb_intra;
5817 s->dct_count[intra]++;
5819 for(i=0; i<64; i++){
5820 int level= block[i];
5824 s->dct_error_sum[intra][i] += level;
5825 level -= s->dct_offset[intra][i];
5826 if(level<0) level=0;
5828 s->dct_error_sum[intra][i] -= level;
5829 level += s->dct_offset[intra][i];
5830 if(level>0) level=0;
5837 static int dct_quantize_trellis_c(MpegEncContext *s,
5838 DCTELEM *block, int n,
5839 int qscale, int *overflow){
5841 const uint8_t *scantable= s->intra_scantable.scantable;
5842 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5844 unsigned int threshold1, threshold2;
5856 int coeff_count[64];
5857 int qmul, qadd, start_i, last_non_zero, i, dc;
5858 const int esc_length= s->ac_esc_length;
5860 uint8_t * last_length;
5861 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5863 s->dsp.fdct (block);
5865 if(s->dct_error_sum)
5866 s->denoise_dct(s, block);
5868 qadd= ((qscale-1)|1)*8;
5879 /* For AIC we skip quant/dequant of INTRADC */
5884 /* note: block[0] is assumed to be positive */
5885 block[0] = (block[0] + (q >> 1)) / q;
5888 qmat = s->q_intra_matrix[qscale];
5889 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5890 bias= 1<<(QMAT_SHIFT-1);
5891 length = s->intra_ac_vlc_length;
5892 last_length= s->intra_ac_vlc_last_length;
5896 qmat = s->q_inter_matrix[qscale];
5897 length = s->inter_ac_vlc_length;
5898 last_length= s->inter_ac_vlc_last_length;
5902 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5903 threshold2= (threshold1<<1);
5905 for(i=63; i>=start_i; i--) {
5906 const int j = scantable[i];
5907 int level = block[j] * qmat[j];
5909 if(((unsigned)(level+threshold1))>threshold2){
5915 for(i=start_i; i<=last_non_zero; i++) {
5916 const int j = scantable[i];
5917 int level = block[j] * qmat[j];
5919 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
5920 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
5921 if(((unsigned)(level+threshold1))>threshold2){
5923 level= (bias + level)>>QMAT_SHIFT;
5925 coeff[1][i]= level-1;
5926 // coeff[2][k]= level-2;
5928 level= (bias - level)>>QMAT_SHIFT;
5929 coeff[0][i]= -level;
5930 coeff[1][i]= -level+1;
5931 // coeff[2][k]= -level+2;
5933 coeff_count[i]= FFMIN(level, 2);
5934 assert(coeff_count[i]);
5937 coeff[0][i]= (level>>31)|1;
5942 *overflow= s->max_qcoeff < max; //overflow might have happened
5944 if(last_non_zero < start_i){
5945 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5946 return last_non_zero;
5949 score_tab[start_i]= 0;
5950 survivor[0]= start_i;
5953 for(i=start_i; i<=last_non_zero; i++){
5955 const int dct_coeff= FFABS(block[ scantable[i] ]);
5956 const int zero_distoration= dct_coeff*dct_coeff;
5957 int best_score=256*256*256*120;
5958 for(level_index=0; level_index < coeff_count[i]; level_index++){
5960 int level= coeff[level_index][i];
5961 const int alevel= FFABS(level);
5966 if(s->out_format == FMT_H263){
5967 unquant_coeff= alevel*qmul + qadd;
5969 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5971 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5972 unquant_coeff = (unquant_coeff - 1) | 1;
5974 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5975 unquant_coeff = (unquant_coeff - 1) | 1;
5980 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5982 if((level&(~127)) == 0){
5983 for(j=survivor_count-1; j>=0; j--){
5984 int run= i - survivor[j];
5985 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5986 score += score_tab[i-run];
5988 if(score < best_score){
5991 level_tab[i+1]= level-64;
5995 if(s->out_format == FMT_H263){
5996 for(j=survivor_count-1; j>=0; j--){
5997 int run= i - survivor[j];
5998 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5999 score += score_tab[i-run];
6000 if(score < last_score){
6003 last_level= level-64;
6009 distoration += esc_length*lambda;
6010 for(j=survivor_count-1; j>=0; j--){
6011 int run= i - survivor[j];
6012 int score= distoration + score_tab[i-run];
6014 if(score < best_score){
6017 level_tab[i+1]= level-64;
6021 if(s->out_format == FMT_H263){
6022 for(j=survivor_count-1; j>=0; j--){
6023 int run= i - survivor[j];
6024 int score= distoration + score_tab[i-run];
6025 if(score < last_score){
6028 last_level= level-64;
6036 score_tab[i+1]= best_score;
6038 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
6039 if(last_non_zero <= 27){
6040 for(; survivor_count; survivor_count--){
6041 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
6045 for(; survivor_count; survivor_count--){
6046 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
6051 survivor[ survivor_count++ ]= i+1;
6054 if(s->out_format != FMT_H263){
6055 last_score= 256*256*256*120;
6056 for(i= survivor[0]; i<=last_non_zero + 1; i++){
6057 int score= score_tab[i];
6058 if(i) score += lambda*2; //FIXME exacter?
6060 if(score < last_score){
6063 last_level= level_tab[i];
6064 last_run= run_tab[i];
6069 s->coded_score[n] = last_score;
6071 dc= FFABS(block[0]);
6072 last_non_zero= last_i - 1;
6073 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
6075 if(last_non_zero < start_i)
6076 return last_non_zero;
6078 if(last_non_zero == 0 && start_i == 0){
6080 int best_score= dc * dc;
6082 for(i=0; i<coeff_count[0]; i++){
6083 int level= coeff[i][0];
6084 int alevel= FFABS(level);
6085 int unquant_coeff, score, distortion;
6087 if(s->out_format == FMT_H263){
6088 unquant_coeff= (alevel*qmul + qadd)>>3;
6090 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
6091 unquant_coeff = (unquant_coeff - 1) | 1;
6093 unquant_coeff = (unquant_coeff + 4) >> 3;
6094 unquant_coeff<<= 3 + 3;
6096 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
6098 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
6099 else score= distortion + esc_length*lambda;
6101 if(score < best_score){
6103 best_level= level - 64;
6106 block[0]= best_level;
6107 s->coded_score[n] = best_score - dc*dc;
6108 if(best_level == 0) return -1;
6109 else return last_non_zero;
6115 block[ perm_scantable[last_non_zero] ]= last_level;
6118 for(; i>start_i; i -= run_tab[i] + 1){
6119 block[ perm_scantable[i-1] ]= level_tab[i];
6122 return last_non_zero;
6125 //#define REFINE_STATS 1
6126 static int16_t basis[64][64];
6128 static void build_basis(uint8_t *perm){
6135 double s= 0.25*(1<<BASIS_SHIFT);
6137 int perm_index= perm[index];
6138 if(i==0) s*= sqrt(0.5);
6139 if(j==0) s*= sqrt(0.5);
6140 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)));
6147 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
6148 DCTELEM *block, int16_t *weight, DCTELEM *orig,
6151 DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6153 const uint8_t *scantable= s->intra_scantable.scantable;
6154 const uint8_t *perm_scantable= s->intra_scantable.permutated;
6155 // unsigned int threshold1, threshold2;
6160 int qmul, qadd, start_i, last_non_zero, i, dc;
6162 uint8_t * last_length;
6164 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
6167 static int after_last=0;
6168 static int to_zero=0;
6169 static int from_zero=0;
6172 static int messed_sign=0;
6175 if(basis[0][0] == 0)
6176 build_basis(s->dsp.idct_permutation);
6187 /* For AIC we skip quant/dequant of INTRADC */
6191 q <<= RECON_SHIFT-3;
6192 /* note: block[0] is assumed to be positive */
6194 // block[0] = (block[0] + (q >> 1)) / q;
6196 qmat = s->q_intra_matrix[qscale];
6197 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
6198 // bias= 1<<(QMAT_SHIFT-1);
6199 length = s->intra_ac_vlc_length;
6200 last_length= s->intra_ac_vlc_last_length;
6204 qmat = s->q_inter_matrix[qscale];
6205 length = s->inter_ac_vlc_length;
6206 last_length= s->inter_ac_vlc_last_length;
6208 last_non_zero = s->block_last_index[n];
6213 dc += (1<<(RECON_SHIFT-1));
6214 for(i=0; i<64; i++){
6215 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6218 STOP_TIMER("memset rem[]")}
6221 for(i=0; i<64; i++){
6226 w= FFABS(weight[i]) + qns*one;
6227 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
6230 // w=weight[i] = (63*qns + (w/2)) / w;
6236 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6242 for(i=start_i; i<=last_non_zero; i++){
6243 int j= perm_scantable[i];
6244 const int level= block[j];
6248 if(level<0) coeff= qmul*level - qadd;
6249 else coeff= qmul*level + qadd;
6250 run_tab[rle_index++]=run;
6253 s->dsp.add_8x8basis(rem, basis[j], coeff);
6259 if(last_non_zero>0){
6260 STOP_TIMER("init rem[]")
6267 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6270 int run2, best_unquant_change=0, analyze_gradient;
6274 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
6276 if(analyze_gradient){
6280 for(i=0; i<64; i++){
6283 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6286 STOP_TIMER("rem*w*w")}
6296 const int level= block[0];
6297 int change, old_coeff;
6299 assert(s->mb_intra);
6303 for(change=-1; change<=1; change+=2){
6304 int new_level= level + change;
6305 int score, new_coeff;
6307 new_coeff= q*new_level;
6308 if(new_coeff >= 2048 || new_coeff < 0)
6311 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6312 if(score<best_score){
6315 best_change= change;
6316 best_unquant_change= new_coeff - old_coeff;
6323 run2= run_tab[rle_index++];
6327 for(i=start_i; i<64; i++){
6328 int j= perm_scantable[i];
6329 const int level= block[j];
6330 int change, old_coeff;
6332 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6336 if(level<0) old_coeff= qmul*level - qadd;
6337 else old_coeff= qmul*level + qadd;
6338 run2= run_tab[rle_index++]; //FIXME ! maybe after last
6342 assert(run2>=0 || i >= last_non_zero );
6345 for(change=-1; change<=1; change+=2){
6346 int new_level= level + change;
6347 int score, new_coeff, unquant_change;
6350 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
6354 if(new_level<0) new_coeff= qmul*new_level - qadd;
6355 else new_coeff= qmul*new_level + qadd;
6356 if(new_coeff >= 2048 || new_coeff <= -2048)
6358 //FIXME check for overflow
6361 if(level < 63 && level > -63){
6362 if(i < last_non_zero)
6363 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6364 - length[UNI_AC_ENC_INDEX(run, level+64)];
6366 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6367 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
6370 assert(FFABS(new_level)==1);
6372 if(analyze_gradient){
6373 int g= d1[ scantable[i] ];
6374 if(g && (g^new_level) >= 0)
6378 if(i < last_non_zero){
6379 int next_i= i + run2 + 1;
6380 int next_level= block[ perm_scantable[next_i] ] + 64;
6382 if(next_level&(~127))
6385 if(next_i < last_non_zero)
6386 score += length[UNI_AC_ENC_INDEX(run, 65)]
6387 + length[UNI_AC_ENC_INDEX(run2, next_level)]
6388 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6390 score += length[UNI_AC_ENC_INDEX(run, 65)]
6391 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6392 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6394 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6396 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6397 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6403 assert(FFABS(level)==1);
6405 if(i < last_non_zero){
6406 int next_i= i + run2 + 1;
6407 int next_level= block[ perm_scantable[next_i] ] + 64;
6409 if(next_level&(~127))
6412 if(next_i < last_non_zero)
6413 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6414 - length[UNI_AC_ENC_INDEX(run2, next_level)]
6415 - length[UNI_AC_ENC_INDEX(run, 65)];
6417 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6418 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6419 - length[UNI_AC_ENC_INDEX(run, 65)];
6421 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6423 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6424 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6431 unquant_change= new_coeff - old_coeff;
6432 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6434 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6435 if(score<best_score){
6438 best_change= change;
6439 best_unquant_change= unquant_change;
6443 prev_level= level + 64;
6444 if(prev_level&(~127))
6453 STOP_TIMER("iterative step")}
6457 int j= perm_scantable[ best_coeff ];
6459 block[j] += best_change;
6461 if(best_coeff > last_non_zero){
6462 last_non_zero= best_coeff;
6470 if(block[j] - best_change){
6471 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
6483 for(; last_non_zero>=start_i; last_non_zero--){
6484 if(block[perm_scantable[last_non_zero]])
6490 if(256*256*256*64 % count == 0){
6491 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);
6496 for(i=start_i; i<=last_non_zero; i++){
6497 int j= perm_scantable[i];
6498 const int level= block[j];
6501 run_tab[rle_index++]=run;
6508 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6514 if(last_non_zero>0){
6515 STOP_TIMER("iterative search")
6520 return last_non_zero;
6523 static int dct_quantize_c(MpegEncContext *s,
6524 DCTELEM *block, int n,
6525 int qscale, int *overflow)
6527 int i, j, level, last_non_zero, q, start_i;
6529 const uint8_t *scantable= s->intra_scantable.scantable;
6532 unsigned int threshold1, threshold2;
6534 s->dsp.fdct (block);
6536 if(s->dct_error_sum)
6537 s->denoise_dct(s, block);
6547 /* For AIC we skip quant/dequant of INTRADC */
6550 /* note: block[0] is assumed to be positive */
6551 block[0] = (block[0] + (q >> 1)) / q;
6554 qmat = s->q_intra_matrix[qscale];
6555 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6559 qmat = s->q_inter_matrix[qscale];
6560 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6562 threshold1= (1<<QMAT_SHIFT) - bias - 1;
6563 threshold2= (threshold1<<1);
6564 for(i=63;i>=start_i;i--) {
6566 level = block[j] * qmat[j];
6568 if(((unsigned)(level+threshold1))>threshold2){
6575 for(i=start_i; i<=last_non_zero; i++) {
6577 level = block[j] * qmat[j];
6579 // if( bias+level >= (1<<QMAT_SHIFT)
6580 // || bias-level >= (1<<QMAT_SHIFT)){
6581 if(((unsigned)(level+threshold1))>threshold2){
6583 level= (bias + level)>>QMAT_SHIFT;
6586 level= (bias - level)>>QMAT_SHIFT;
6594 *overflow= s->max_qcoeff < max; //overflow might have happened
6596 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6597 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6598 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6600 return last_non_zero;
6603 #endif //CONFIG_ENCODERS
6605 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6606 DCTELEM *block, int n, int qscale)
6608 int i, level, nCoeffs;
6609 const uint16_t *quant_matrix;
6611 nCoeffs= s->block_last_index[n];
6614 block[0] = block[0] * s->y_dc_scale;
6616 block[0] = block[0] * s->c_dc_scale;
6617 /* XXX: only mpeg1 */
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;
6626 level = (level - 1) | 1;
6629 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6630 level = (level - 1) | 1;
6637 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6638 DCTELEM *block, int n, int qscale)
6640 int i, level, nCoeffs;
6641 const uint16_t *quant_matrix;
6643 nCoeffs= s->block_last_index[n];
6645 quant_matrix = s->inter_matrix;
6646 for(i=0; i<=nCoeffs; i++) {
6647 int j= s->intra_scantable.permutated[i];
6652 level = (((level << 1) + 1) * qscale *
6653 ((int) (quant_matrix[j]))) >> 4;
6654 level = (level - 1) | 1;
6657 level = (((level << 1) + 1) * qscale *
6658 ((int) (quant_matrix[j]))) >> 4;
6659 level = (level - 1) | 1;
6666 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6667 DCTELEM *block, int n, int qscale)
6669 int i, level, nCoeffs;
6670 const uint16_t *quant_matrix;
6672 if(s->alternate_scan) nCoeffs= 63;
6673 else nCoeffs= s->block_last_index[n];
6676 block[0] = block[0] * s->y_dc_scale;
6678 block[0] = block[0] * s->c_dc_scale;
6679 quant_matrix = s->intra_matrix;
6680 for(i=1;i<=nCoeffs;i++) {
6681 int j= s->intra_scantable.permutated[i];
6686 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6689 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6696 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
6697 DCTELEM *block, int n, int qscale)
6699 int i, level, nCoeffs;
6700 const uint16_t *quant_matrix;
6703 if(s->alternate_scan) nCoeffs= 63;
6704 else nCoeffs= s->block_last_index[n];
6707 block[0] = block[0] * s->y_dc_scale;
6709 block[0] = block[0] * s->c_dc_scale;
6710 quant_matrix = s->intra_matrix;
6711 for(i=1;i<=nCoeffs;i++) {
6712 int j= s->intra_scantable.permutated[i];
6717 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6720 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6729 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6730 DCTELEM *block, int n, int qscale)
6732 int i, level, nCoeffs;
6733 const uint16_t *quant_matrix;
6736 if(s->alternate_scan) nCoeffs= 63;
6737 else nCoeffs= s->block_last_index[n];
6739 quant_matrix = s->inter_matrix;
6740 for(i=0; i<=nCoeffs; i++) {
6741 int j= s->intra_scantable.permutated[i];
6746 level = (((level << 1) + 1) * qscale *
6747 ((int) (quant_matrix[j]))) >> 4;
6750 level = (((level << 1) + 1) * qscale *
6751 ((int) (quant_matrix[j]))) >> 4;
6760 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6761 DCTELEM *block, int n, int qscale)
6763 int i, level, qmul, qadd;
6766 assert(s->block_last_index[n]>=0);
6772 block[0] = block[0] * s->y_dc_scale;
6774 block[0] = block[0] * s->c_dc_scale;
6775 qadd = (qscale - 1) | 1;
6782 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6784 for(i=1; i<=nCoeffs; i++) {
6788 level = level * qmul - qadd;
6790 level = level * qmul + qadd;
6797 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6798 DCTELEM *block, int n, int qscale)
6800 int i, level, qmul, qadd;
6803 assert(s->block_last_index[n]>=0);
6805 qadd = (qscale - 1) | 1;
6808 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6810 for(i=0; i<=nCoeffs; i++) {
6814 level = level * qmul - qadd;
6816 level = level * qmul + qadd;
6823 #ifdef CONFIG_ENCODERS
6824 AVCodec h263_encoder = {
6828 sizeof(MpegEncContext),
6832 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6835 AVCodec h263p_encoder = {
6839 sizeof(MpegEncContext),
6843 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6846 AVCodec flv_encoder = {
6850 sizeof(MpegEncContext),
6854 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6857 AVCodec rv10_encoder = {
6861 sizeof(MpegEncContext),
6865 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6868 AVCodec rv20_encoder = {
6872 sizeof(MpegEncContext),
6876 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6879 AVCodec mpeg4_encoder = {
6883 sizeof(MpegEncContext),
6887 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6888 .capabilities= CODEC_CAP_DELAY,
6891 AVCodec msmpeg4v1_encoder = {
6895 sizeof(MpegEncContext),
6899 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6902 AVCodec msmpeg4v2_encoder = {
6906 sizeof(MpegEncContext),
6910 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6913 AVCodec msmpeg4v3_encoder = {
6917 sizeof(MpegEncContext),
6921 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6924 AVCodec wmv1_encoder = {
6928 sizeof(MpegEncContext),
6932 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6935 AVCodec mjpeg_encoder = {
6939 sizeof(MpegEncContext),
6943 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1},
6946 #endif //CONFIG_ENCODERS