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 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * @file libavcodec/mpegvideo_enc.c
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
33 #include "mpegvideo_common.h"
38 #include "aandcttab.h"
44 static int encode_picture(MpegEncContext
*s
, int picture_number
);
45 static int dct_quantize_refine(MpegEncContext
*s
, DCTELEM
*block
, int16_t *weight
, DCTELEM
*orig
, int n
, int qscale
);
46 static int sse_mb(MpegEncContext
*s
);
48 /* enable all paranoid tests for rounding, overflows, etc... */
53 static uint8_t default_mv_penalty
[MAX_FCODE
+1][MAX_MV
*2+1];
54 static uint8_t default_fcode_tab
[MAX_MV
*2+1];
56 void ff_convert_matrix(DSPContext
*dsp
, int (*qmat
)[64], uint16_t (*qmat16
)[2][64],
57 const uint16_t *quant_matrix
, int bias
, int qmin
, int qmax
, int intra
)
62 for(qscale
=qmin
; qscale
<=qmax
; qscale
++){
64 if (dsp
->fdct
== ff_jpeg_fdct_islow
66 || dsp
->fdct
== ff_faandct
70 const int j
= dsp
->idct_permutation
[i
];
71 /* 16 <= qscale * quant_matrix[i] <= 7905 */
72 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
73 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1 << 36) / 249205026 */
74 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */
76 qmat
[qscale
][i
] = (int)((UINT64_C(1) << QMAT_SHIFT
) /
77 (qscale
* quant_matrix
[j
]));
79 } else if (dsp
->fdct
== fdct_ifast
80 #ifndef FAAN_POSTSCALE
81 || dsp
->fdct
== ff_faandct
85 const int j
= dsp
->idct_permutation
[i
];
86 /* 16 <= qscale * quant_matrix[i] <= 7905 */
87 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
88 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
89 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */
91 qmat
[qscale
][i
] = (int)((UINT64_C(1) << (QMAT_SHIFT
+ 14)) /
92 (ff_aanscales
[i
] * qscale
* quant_matrix
[j
]));
96 const int j
= dsp
->idct_permutation
[i
];
97 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
98 So 16 <= qscale * quant_matrix[i] <= 7905
99 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
100 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
102 qmat
[qscale
][i
] = (int)((UINT64_C(1) << QMAT_SHIFT
) / (qscale
* quant_matrix
[j
]));
103 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
104 qmat16
[qscale
][0][i
] = (1 << QMAT_SHIFT_MMX
) / (qscale
* quant_matrix
[j
]);
106 if(qmat16
[qscale
][0][i
]==0 || qmat16
[qscale
][0][i
]==128*256) qmat16
[qscale
][0][i
]=128*256-1;
107 qmat16
[qscale
][1][i
]= ROUNDED_DIV(bias
<<(16-QUANT_BIAS_SHIFT
), qmat16
[qscale
][0][i
]);
111 for(i
=intra
; i
<64; i
++){
113 if (dsp
->fdct
== fdct_ifast
114 #ifndef FAAN_POSTSCALE
115 || dsp
->fdct
== ff_faandct
118 max
= (8191LL*ff_aanscales
[i
]) >> 14;
120 while(((max
* qmat
[qscale
][i
]) >> shift
) > INT_MAX
){
126 av_log(NULL
, AV_LOG_INFO
, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT
- shift
);
130 static inline void update_qscale(MpegEncContext
*s
){
131 s
->qscale
= (s
->lambda
*139 + FF_LAMBDA_SCALE
*64) >> (FF_LAMBDA_SHIFT
+ 7);
132 s
->qscale
= av_clip(s
->qscale
, s
->avctx
->qmin
, s
->avctx
->qmax
);
134 s
->lambda2
= (s
->lambda
*s
->lambda
+ FF_LAMBDA_SCALE
/2) >> FF_LAMBDA_SHIFT
;
137 void ff_write_quant_matrix(PutBitContext
*pb
, uint16_t *matrix
){
143 put_bits(pb
, 8, matrix
[ ff_zigzag_direct
[i
] ]);
149 static void copy_picture_attributes(MpegEncContext
*s
, AVFrame
*dst
, AVFrame
*src
){
152 dst
->pict_type
= src
->pict_type
;
153 dst
->quality
= src
->quality
;
154 dst
->coded_picture_number
= src
->coded_picture_number
;
155 dst
->display_picture_number
= src
->display_picture_number
;
156 // dst->reference = src->reference;
158 dst
->interlaced_frame
= src
->interlaced_frame
;
159 dst
->top_field_first
= src
->top_field_first
;
161 if(s
->avctx
->me_threshold
){
162 if(!src
->motion_val
[0])
163 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.motion_val not set!\n");
165 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.mb_type not set!\n");
166 if(!src
->ref_index
[0])
167 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.ref_index not set!\n");
168 if(src
->motion_subsample_log2
!= dst
->motion_subsample_log2
)
169 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
170 src
->motion_subsample_log2
, dst
->motion_subsample_log2
);
172 memcpy(dst
->mb_type
, src
->mb_type
, s
->mb_stride
* s
->mb_height
* sizeof(dst
->mb_type
[0]));
175 int stride
= ((16*s
->mb_width
)>>src
->motion_subsample_log2
) + 1;
176 int height
= ((16*s
->mb_height
)>>src
->motion_subsample_log2
);
178 if(src
->motion_val
[i
] && src
->motion_val
[i
] != dst
->motion_val
[i
]){
179 memcpy(dst
->motion_val
[i
], src
->motion_val
[i
], 2*stride
*height
*sizeof(int16_t));
181 if(src
->ref_index
[i
] && src
->ref_index
[i
] != dst
->ref_index
[i
]){
182 memcpy(dst
->ref_index
[i
], src
->ref_index
[i
], s
->b8_stride
*2*s
->mb_height
*sizeof(int8_t));
188 static void update_duplicate_context_after_me(MpegEncContext
*dst
, MpegEncContext
*src
){
189 #define COPY(a) dst->a= src->a
191 COPY(current_picture
);
197 COPY(picture_in_gop_number
);
198 COPY(gop_picture_number
);
199 COPY(frame_pred_frame_dct
); //FIXME don't set in encode_header
200 COPY(progressive_frame
); //FIXME don't set in encode_header
201 COPY(partitioned_frame
); //FIXME don't set in encode_header
206 * sets the given MpegEncContext to defaults for encoding.
207 * the changed fields will not depend upon the prior state of the MpegEncContext.
209 static void MPV_encode_defaults(MpegEncContext
*s
){
211 MPV_common_defaults(s
);
213 for(i
=-16; i
<16; i
++){
214 default_fcode_tab
[i
+ MAX_MV
]= 1;
216 s
->me
.mv_penalty
= default_mv_penalty
;
217 s
->fcode_tab
= default_fcode_tab
;
220 /* init video encoder */
221 av_cold
int MPV_encode_init(AVCodecContext
*avctx
)
223 MpegEncContext
*s
= avctx
->priv_data
;
225 int chroma_h_shift
, chroma_v_shift
;
227 MPV_encode_defaults(s
);
229 switch (avctx
->codec_id
) {
230 case CODEC_ID_MPEG2VIDEO
:
231 if(avctx
->pix_fmt
!= PIX_FMT_YUV420P
&& avctx
->pix_fmt
!= PIX_FMT_YUV422P
){
232 av_log(avctx
, AV_LOG_ERROR
, "only YUV420 and YUV422 are supported\n");
238 if(avctx
->pix_fmt
!= PIX_FMT_YUVJ420P
&& avctx
->pix_fmt
!= PIX_FMT_YUVJ422P
&& avctx
->pix_fmt
!= PIX_FMT_RGB32
&&
239 ((avctx
->pix_fmt
!= PIX_FMT_YUV420P
&& avctx
->pix_fmt
!= PIX_FMT_YUV422P
) || avctx
->strict_std_compliance
>FF_COMPLIANCE_INOFFICIAL
)){
240 av_log(avctx
, AV_LOG_ERROR
, "colorspace not supported in jpeg\n");
245 if(avctx
->pix_fmt
!= PIX_FMT_YUV420P
){
246 av_log(avctx
, AV_LOG_ERROR
, "only YUV420 is supported\n");
251 switch (avctx
->pix_fmt
) {
252 case PIX_FMT_YUVJ422P
:
253 case PIX_FMT_YUV422P
:
254 s
->chroma_format
= CHROMA_422
;
256 case PIX_FMT_YUVJ420P
:
257 case PIX_FMT_YUV420P
:
259 s
->chroma_format
= CHROMA_420
;
263 s
->bit_rate
= avctx
->bit_rate
;
264 s
->width
= avctx
->width
;
265 s
->height
= avctx
->height
;
266 if(avctx
->gop_size
> 600 && avctx
->strict_std_compliance
>FF_COMPLIANCE_EXPERIMENTAL
){
267 av_log(avctx
, AV_LOG_ERROR
, "Warning keyframe interval too large! reducing it ...\n");
270 s
->gop_size
= avctx
->gop_size
;
272 s
->flags
= avctx
->flags
;
273 s
->flags2
= avctx
->flags2
;
274 s
->max_b_frames
= avctx
->max_b_frames
;
275 s
->codec_id
= avctx
->codec
->id
;
276 s
->luma_elim_threshold
= avctx
->luma_elim_threshold
;
277 s
->chroma_elim_threshold
= avctx
->chroma_elim_threshold
;
278 s
->strict_std_compliance
= avctx
->strict_std_compliance
;
279 s
->data_partitioning
= avctx
->flags
& CODEC_FLAG_PART
;
280 s
->quarter_sample
= (avctx
->flags
& CODEC_FLAG_QPEL
)!=0;
281 s
->mpeg_quant
= avctx
->mpeg_quant
;
282 s
->rtp_mode
= !!avctx
->rtp_payload_size
;
283 s
->intra_dc_precision
= avctx
->intra_dc_precision
;
284 s
->user_specified_pts
= AV_NOPTS_VALUE
;
286 if (s
->gop_size
<= 1) {
293 s
->me_method
= avctx
->me_method
;
296 s
->fixed_qscale
= !!(avctx
->flags
& CODEC_FLAG_QSCALE
);
298 s
->adaptive_quant
= ( s
->avctx
->lumi_masking
299 || s
->avctx
->dark_masking
300 || s
->avctx
->temporal_cplx_masking
301 || s
->avctx
->spatial_cplx_masking
302 || s
->avctx
->p_masking
303 || s
->avctx
->border_masking
304 || (s
->flags
&CODEC_FLAG_QP_RD
))
307 s
->obmc
= !!(s
->flags
& CODEC_FLAG_OBMC
);
308 s
->loop_filter
= !!(s
->flags
& CODEC_FLAG_LOOP_FILTER
);
309 s
->alternate_scan
= !!(s
->flags
& CODEC_FLAG_ALT_SCAN
);
310 s
->intra_vlc_format
= !!(s
->flags2
& CODEC_FLAG2_INTRA_VLC
);
311 s
->q_scale_type
= !!(s
->flags2
& CODEC_FLAG2_NON_LINEAR_QUANT
);
313 if(avctx
->rc_max_rate
&& !avctx
->rc_buffer_size
){
314 av_log(avctx
, AV_LOG_ERROR
, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
318 if(avctx
->rc_min_rate
&& avctx
->rc_max_rate
!= avctx
->rc_min_rate
){
319 av_log(avctx
, AV_LOG_INFO
, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
322 if(avctx
->rc_min_rate
&& avctx
->rc_min_rate
> avctx
->bit_rate
){
323 av_log(avctx
, AV_LOG_ERROR
, "bitrate below min bitrate\n");
327 if(avctx
->rc_max_rate
&& avctx
->rc_max_rate
< avctx
->bit_rate
){
328 av_log(avctx
, AV_LOG_INFO
, "bitrate above max bitrate\n");
332 if(avctx
->rc_max_rate
&& avctx
->rc_max_rate
== avctx
->bit_rate
&& avctx
->rc_max_rate
!= avctx
->rc_min_rate
){
333 av_log(avctx
, AV_LOG_INFO
, "impossible bitrate constraints, this will fail\n");
336 if(avctx
->rc_buffer_size
&& avctx
->bit_rate
*av_q2d(avctx
->time_base
) > avctx
->rc_buffer_size
){
337 av_log(avctx
, AV_LOG_ERROR
, "VBV buffer too small for bitrate\n");
341 if(avctx
->bit_rate
*av_q2d(avctx
->time_base
) > avctx
->bit_rate_tolerance
){
342 av_log(avctx
, AV_LOG_ERROR
, "bitrate tolerance too small for bitrate\n");
346 if( s
->avctx
->rc_max_rate
&& s
->avctx
->rc_min_rate
== s
->avctx
->rc_max_rate
347 && (s
->codec_id
== CODEC_ID_MPEG1VIDEO
|| s
->codec_id
== CODEC_ID_MPEG2VIDEO
)
348 && 90000LL * (avctx
->rc_buffer_size
-1) > s
->avctx
->rc_max_rate
*0xFFFFLL
){
350 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");
353 if((s
->flags
& CODEC_FLAG_4MV
) && s
->codec_id
!= CODEC_ID_MPEG4
354 && s
->codec_id
!= CODEC_ID_H263
&& s
->codec_id
!= CODEC_ID_H263P
&& s
->codec_id
!= CODEC_ID_FLV1
){
355 av_log(avctx
, AV_LOG_ERROR
, "4MV not supported by codec\n");
359 if(s
->obmc
&& s
->avctx
->mb_decision
!= FF_MB_DECISION_SIMPLE
){
360 av_log(avctx
, AV_LOG_ERROR
, "OBMC is only supported with simple mb decision\n");
364 if(s
->obmc
&& s
->codec_id
!= CODEC_ID_H263
&& s
->codec_id
!= CODEC_ID_H263P
){
365 av_log(avctx
, AV_LOG_ERROR
, "OBMC is only supported with H263(+)\n");
369 if(s
->quarter_sample
&& s
->codec_id
!= CODEC_ID_MPEG4
){
370 av_log(avctx
, AV_LOG_ERROR
, "qpel not supported by codec\n");
374 if(s
->data_partitioning
&& s
->codec_id
!= CODEC_ID_MPEG4
){
375 av_log(avctx
, AV_LOG_ERROR
, "data partitioning not supported by codec\n");
379 if(s
->max_b_frames
&& s
->codec_id
!= CODEC_ID_MPEG4
&& s
->codec_id
!= CODEC_ID_MPEG1VIDEO
&& s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
380 av_log(avctx
, AV_LOG_ERROR
, "b frames not supported by codec\n");
384 if((s
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
|CODEC_FLAG_ALT_SCAN
))
385 && s
->codec_id
!= CODEC_ID_MPEG4
&& s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
386 av_log(avctx
, AV_LOG_ERROR
, "interlacing not supported by codec\n");
390 if(s
->mpeg_quant
&& s
->codec_id
!= CODEC_ID_MPEG4
){ //FIXME mpeg2 uses that too
391 av_log(avctx
, AV_LOG_ERROR
, "mpeg2 style quantization not supported by codec\n");
395 if((s
->flags
& CODEC_FLAG_CBP_RD
) && !avctx
->trellis
){
396 av_log(avctx
, AV_LOG_ERROR
, "CBP RD needs trellis quant\n");
400 if((s
->flags
& CODEC_FLAG_QP_RD
) && s
->avctx
->mb_decision
!= FF_MB_DECISION_RD
){
401 av_log(avctx
, AV_LOG_ERROR
, "QP RD needs mbd=2\n");
405 if(s
->avctx
->scenechange_threshold
< 1000000000 && (s
->flags
& CODEC_FLAG_CLOSED_GOP
)){
406 av_log(avctx
, AV_LOG_ERROR
, "closed gop with scene change detection are not supported yet, set threshold to 1000000000\n");
410 if((s
->flags2
& CODEC_FLAG2_INTRA_VLC
) && s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
411 av_log(avctx
, AV_LOG_ERROR
, "intra vlc table not supported by codec\n");
415 if(s
->flags
& CODEC_FLAG_LOW_DELAY
){
416 if (s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
417 av_log(avctx
, AV_LOG_ERROR
, "low delay forcing is only available for mpeg2\n");
420 if (s
->max_b_frames
!= 0){
421 av_log(avctx
, AV_LOG_ERROR
, "b frames cannot be used with low delay\n");
426 if(s
->q_scale_type
== 1){
427 if(s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
428 av_log(avctx
, AV_LOG_ERROR
, "non linear quant is only available for mpeg2\n");
431 if(avctx
->qmax
> 12){
432 av_log(avctx
, AV_LOG_ERROR
, "non linear quant only supports qmax <= 12 currently\n");
437 if(s
->avctx
->thread_count
> 1 && s
->codec_id
!= CODEC_ID_MPEG4
438 && s
->codec_id
!= CODEC_ID_MPEG1VIDEO
&& s
->codec_id
!= CODEC_ID_MPEG2VIDEO
439 && (s
->codec_id
!= CODEC_ID_H263P
|| !(s
->flags
& CODEC_FLAG_H263P_SLICE_STRUCT
))){
440 av_log(avctx
, AV_LOG_ERROR
, "multi threaded encoding not supported by codec\n");
444 if(s
->avctx
->thread_count
> 1)
447 if(!avctx
->time_base
.den
|| !avctx
->time_base
.num
){
448 av_log(avctx
, AV_LOG_ERROR
, "framerate not set\n");
452 i
= (INT_MAX
/2+128)>>8;
453 if(avctx
->me_threshold
>= i
){
454 av_log(avctx
, AV_LOG_ERROR
, "me_threshold too large, max is %d\n", i
- 1);
457 if(avctx
->mb_threshold
>= i
){
458 av_log(avctx
, AV_LOG_ERROR
, "mb_threshold too large, max is %d\n", i
- 1);
462 if(avctx
->b_frame_strategy
&& (avctx
->flags
&CODEC_FLAG_PASS2
)){
463 av_log(avctx
, AV_LOG_INFO
, "notice: b_frame_strategy only affects the first pass\n");
464 avctx
->b_frame_strategy
= 0;
467 i
= av_gcd(avctx
->time_base
.den
, avctx
->time_base
.num
);
469 av_log(avctx
, AV_LOG_INFO
, "removing common factors from framerate\n");
470 avctx
->time_base
.den
/= i
;
471 avctx
->time_base
.num
/= i
;
475 if(s
->codec_id
==CODEC_ID_MJPEG
){
476 s
->intra_quant_bias
= 1<<(QUANT_BIAS_SHIFT
-1); //(a + x/2)/x
477 s
->inter_quant_bias
= 0;
478 }else if(s
->mpeg_quant
|| s
->codec_id
==CODEC_ID_MPEG1VIDEO
|| s
->codec_id
==CODEC_ID_MPEG2VIDEO
){
479 s
->intra_quant_bias
= 3<<(QUANT_BIAS_SHIFT
-3); //(a + x*3/8)/x
480 s
->inter_quant_bias
= 0;
482 s
->intra_quant_bias
=0;
483 s
->inter_quant_bias
=-(1<<(QUANT_BIAS_SHIFT
-2)); //(a - x/4)/x
486 if(avctx
->intra_quant_bias
!= FF_DEFAULT_QUANT_BIAS
)
487 s
->intra_quant_bias
= avctx
->intra_quant_bias
;
488 if(avctx
->inter_quant_bias
!= FF_DEFAULT_QUANT_BIAS
)
489 s
->inter_quant_bias
= avctx
->inter_quant_bias
;
491 avcodec_get_chroma_sub_sample(avctx
->pix_fmt
, &chroma_h_shift
, &chroma_v_shift
);
493 if(avctx
->codec_id
== CODEC_ID_MPEG4
&& s
->avctx
->time_base
.den
> (1<<16)-1){
494 av_log(avctx
, AV_LOG_ERROR
, "timebase not supported by mpeg 4 standard\n");
497 s
->time_increment_bits
= av_log2(s
->avctx
->time_base
.den
- 1) + 1;
499 switch(avctx
->codec
->id
) {
500 case CODEC_ID_MPEG1VIDEO
:
501 s
->out_format
= FMT_MPEG1
;
502 s
->low_delay
= !!(s
->flags
& CODEC_FLAG_LOW_DELAY
);
503 avctx
->delay
= s
->low_delay
? 0 : (s
->max_b_frames
+ 1);
505 case CODEC_ID_MPEG2VIDEO
:
506 s
->out_format
= FMT_MPEG1
;
507 s
->low_delay
= !!(s
->flags
& CODEC_FLAG_LOW_DELAY
);
508 avctx
->delay
= s
->low_delay
? 0 : (s
->max_b_frames
+ 1);
513 s
->out_format
= FMT_MJPEG
;
514 s
->intra_only
= 1; /* force intra only for jpeg */
515 s
->mjpeg_vsample
[0] = 2;
516 s
->mjpeg_vsample
[1] = 2>>chroma_v_shift
;
517 s
->mjpeg_vsample
[2] = 2>>chroma_v_shift
;
518 s
->mjpeg_hsample
[0] = 2;
519 s
->mjpeg_hsample
[1] = 2>>chroma_h_shift
;
520 s
->mjpeg_hsample
[2] = 2>>chroma_h_shift
;
521 if (!(CONFIG_MJPEG_ENCODER
|| CONFIG_LJPEG_ENCODER
)
522 || ff_mjpeg_encode_init(s
) < 0)
528 if (!CONFIG_H261_ENCODER
) return -1;
529 if (ff_h261_get_picture_format(s
->width
, s
->height
) < 0) {
530 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
);
533 s
->out_format
= FMT_H261
;
538 if (!CONFIG_H263_ENCODER
) return -1;
539 if (h263_get_picture_format(s
->width
, s
->height
) == 7) {
540 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
);
543 s
->out_format
= FMT_H263
;
544 s
->obmc
= (avctx
->flags
& CODEC_FLAG_OBMC
) ? 1:0;
549 s
->out_format
= FMT_H263
;
552 s
->umvplus
= (avctx
->flags
& CODEC_FLAG_H263P_UMV
) ? 1:0;
553 s
->h263_aic
= (avctx
->flags
& CODEC_FLAG_AC_PRED
) ? 1:0;
554 s
->modified_quant
= s
->h263_aic
;
555 s
->alt_inter_vlc
= (avctx
->flags
& CODEC_FLAG_H263P_AIV
) ? 1:0;
556 s
->obmc
= (avctx
->flags
& CODEC_FLAG_OBMC
) ? 1:0;
557 s
->loop_filter
= (avctx
->flags
& CODEC_FLAG_LOOP_FILTER
) ? 1:0;
558 s
->unrestricted_mv
= s
->obmc
|| s
->loop_filter
|| s
->umvplus
;
559 s
->h263_slice_structured
= (s
->flags
& CODEC_FLAG_H263P_SLICE_STRUCT
) ? 1:0;
562 /* These are just to be sure */
567 s
->out_format
= FMT_H263
;
568 s
->h263_flv
= 2; /* format = 1; 11-bit codes */
569 s
->unrestricted_mv
= 1;
570 s
->rtp_mode
=0; /* don't allow GOB */
575 s
->out_format
= FMT_H263
;
580 s
->out_format
= FMT_H263
;
587 s
->unrestricted_mv
= s
->obmc
|| s
->loop_filter
|| s
->umvplus
;
590 s
->out_format
= FMT_H263
;
592 s
->unrestricted_mv
= 1;
593 s
->low_delay
= s
->max_b_frames
? 0 : 1;
594 avctx
->delay
= s
->low_delay
? 0 : (s
->max_b_frames
+ 1);
596 case CODEC_ID_MSMPEG4V1
:
597 s
->out_format
= FMT_H263
;
600 s
->unrestricted_mv
= 1;
601 s
->msmpeg4_version
= 1;
605 case CODEC_ID_MSMPEG4V2
:
606 s
->out_format
= FMT_H263
;
609 s
->unrestricted_mv
= 1;
610 s
->msmpeg4_version
= 2;
614 case CODEC_ID_MSMPEG4V3
:
615 s
->out_format
= FMT_H263
;
618 s
->unrestricted_mv
= 1;
619 s
->msmpeg4_version
= 3;
620 s
->flipflop_rounding
=1;
625 s
->out_format
= FMT_H263
;
628 s
->unrestricted_mv
= 1;
629 s
->msmpeg4_version
= 4;
630 s
->flipflop_rounding
=1;
635 s
->out_format
= FMT_H263
;
638 s
->unrestricted_mv
= 1;
639 s
->msmpeg4_version
= 5;
640 s
->flipflop_rounding
=1;
648 avctx
->has_b_frames
= !s
->low_delay
;
652 s
->progressive_frame
=
653 s
->progressive_sequence
= !(avctx
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
|CODEC_FLAG_ALT_SCAN
));
656 if (MPV_common_init(s
) < 0)
660 s
->dct_quantize
= dct_quantize_c
;
662 s
->denoise_dct
= denoise_dct_c
;
663 s
->fast_dct_quantize
= s
->dct_quantize
;
665 s
->dct_quantize
= dct_quantize_trellis_c
;
667 if((CONFIG_H263P_ENCODER
|| CONFIG_RV20_ENCODER
) && s
->modified_quant
)
668 s
->chroma_qscale_table
= ff_h263_chroma_qscale_table
;
670 s
->quant_precision
=5;
672 ff_set_cmp(&s
->dsp
, s
->dsp
.ildct_cmp
, s
->avctx
->ildct_cmp
);
673 ff_set_cmp(&s
->dsp
, s
->dsp
.frame_skip_cmp
, s
->avctx
->frame_skip_cmp
);
675 if (CONFIG_H261_ENCODER
&& s
->out_format
== FMT_H261
)
676 ff_h261_encode_init(s
);
677 if (CONFIG_ANY_H263_ENCODER
&& s
->out_format
== FMT_H263
)
679 if (CONFIG_MSMPEG4_ENCODER
&& s
->msmpeg4_version
)
680 ff_msmpeg4_encode_init(s
);
681 if ((CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
)
682 && s
->out_format
== FMT_MPEG1
)
683 ff_mpeg1_encode_init(s
);
687 int j
= s
->dsp
.idct_permutation
[i
];
688 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
==CODEC_ID_MPEG4
&& s
->mpeg_quant
){
689 s
->intra_matrix
[j
] = ff_mpeg4_default_intra_matrix
[i
];
690 s
->inter_matrix
[j
] = ff_mpeg4_default_non_intra_matrix
[i
];
691 }else if(s
->out_format
== FMT_H263
|| s
->out_format
== FMT_H261
){
693 s
->inter_matrix
[j
] = ff_mpeg1_default_non_intra_matrix
[i
];
696 s
->intra_matrix
[j
] = ff_mpeg1_default_intra_matrix
[i
];
697 s
->inter_matrix
[j
] = ff_mpeg1_default_non_intra_matrix
[i
];
699 if(s
->avctx
->intra_matrix
)
700 s
->intra_matrix
[j
] = s
->avctx
->intra_matrix
[i
];
701 if(s
->avctx
->inter_matrix
)
702 s
->inter_matrix
[j
] = s
->avctx
->inter_matrix
[i
];
705 /* precompute matrix */
706 /* for mjpeg, we do include qscale in the matrix */
707 if (s
->out_format
!= FMT_MJPEG
) {
708 ff_convert_matrix(&s
->dsp
, s
->q_intra_matrix
, s
->q_intra_matrix16
,
709 s
->intra_matrix
, s
->intra_quant_bias
, avctx
->qmin
, 31, 1);
710 ff_convert_matrix(&s
->dsp
, s
->q_inter_matrix
, s
->q_inter_matrix16
,
711 s
->inter_matrix
, s
->inter_quant_bias
, avctx
->qmin
, 31, 0);
714 if(ff_rate_control_init(s
) < 0)
720 av_cold
int MPV_encode_end(AVCodecContext
*avctx
)
722 MpegEncContext
*s
= avctx
->priv_data
;
724 ff_rate_control_uninit(s
);
727 if ((CONFIG_MJPEG_ENCODER
|| CONFIG_LJPEG_ENCODER
) && s
->out_format
== FMT_MJPEG
)
728 ff_mjpeg_encode_close(s
);
730 av_freep(&avctx
->extradata
);
735 static int get_sae(uint8_t *src
, int ref
, int stride
){
741 acc
+= FFABS(src
[x
+y
*stride
] - ref
);
748 static int get_intra_count(MpegEncContext
*s
, uint8_t *src
, uint8_t *ref
, int stride
){
755 for(y
=0; y
<h
; y
+=16){
756 for(x
=0; x
<w
; x
+=16){
757 int offset
= x
+ y
*stride
;
758 int sad
= s
->dsp
.sad
[0](NULL
, src
+ offset
, ref
+ offset
, stride
, 16);
759 int mean
= (s
->dsp
.pix_sum(src
+ offset
, stride
) + 128)>>8;
760 int sae
= get_sae(src
+ offset
, mean
, stride
);
762 acc
+= sae
+ 500 < sad
;
769 static int load_input_picture(MpegEncContext
*s
, AVFrame
*pic_arg
){
773 const int encoding_delay
= s
->max_b_frames
;
778 pic_arg
->display_picture_number
= s
->input_picture_number
++;
780 if(pts
!= AV_NOPTS_VALUE
){
781 if(s
->user_specified_pts
!= AV_NOPTS_VALUE
){
783 int64_t last
= s
->user_specified_pts
;
786 av_log(s
->avctx
, AV_LOG_ERROR
, "Error, Invalid timestamp=%"PRId64
", last=%"PRId64
"\n", pts
, s
->user_specified_pts
);
790 s
->user_specified_pts
= pts
;
792 if(s
->user_specified_pts
!= AV_NOPTS_VALUE
){
793 s
->user_specified_pts
=
794 pts
= s
->user_specified_pts
+ 1;
795 av_log(s
->avctx
, AV_LOG_INFO
, "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n", pts
);
797 pts
= pic_arg
->display_picture_number
;
803 if(encoding_delay
&& !(s
->flags
&CODEC_FLAG_INPUT_PRESERVED
)) direct
=0;
804 if(pic_arg
->linesize
[0] != s
->linesize
) direct
=0;
805 if(pic_arg
->linesize
[1] != s
->uvlinesize
) direct
=0;
806 if(pic_arg
->linesize
[2] != s
->uvlinesize
) direct
=0;
808 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
811 i
= ff_find_unused_picture(s
, 1);
813 pic
= (AVFrame
*)&s
->picture
[i
];
817 pic
->data
[i
]= pic_arg
->data
[i
];
818 pic
->linesize
[i
]= pic_arg
->linesize
[i
];
820 ff_alloc_picture(s
, (Picture
*)pic
, 1);
822 i
= ff_find_unused_picture(s
, 0);
824 pic
= (AVFrame
*)&s
->picture
[i
];
827 ff_alloc_picture(s
, (Picture
*)pic
, 0);
829 if( pic
->data
[0] + INPLACE_OFFSET
== pic_arg
->data
[0]
830 && pic
->data
[1] + INPLACE_OFFSET
== pic_arg
->data
[1]
831 && pic
->data
[2] + INPLACE_OFFSET
== pic_arg
->data
[2]){
834 int h_chroma_shift
, v_chroma_shift
;
835 avcodec_get_chroma_sub_sample(s
->avctx
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
838 int src_stride
= pic_arg
->linesize
[i
];
839 int dst_stride
= i
? s
->uvlinesize
: s
->linesize
;
840 int h_shift
= i
? h_chroma_shift
: 0;
841 int v_shift
= i
? v_chroma_shift
: 0;
842 int w
= s
->width
>>h_shift
;
843 int h
= s
->height
>>v_shift
;
844 uint8_t *src
= pic_arg
->data
[i
];
845 uint8_t *dst
= pic
->data
[i
];
847 if(!s
->avctx
->rc_buffer_size
)
848 dst
+=INPLACE_OFFSET
;
850 if(src_stride
==dst_stride
)
851 memcpy(dst
, src
, src_stride
*h
);
862 copy_picture_attributes(s
, pic
, pic_arg
);
863 pic
->pts
= pts
; //we set this here to avoid modifiying pic_arg
866 /* shift buffer entries */
867 for(i
=1; i
<MAX_PICTURE_COUNT
/*s->encoding_delay+1*/; i
++)
868 s
->input_picture
[i
-1]= s
->input_picture
[i
];
870 s
->input_picture
[encoding_delay
]= (Picture
*)pic
;
875 static int skip_check(MpegEncContext
*s
, Picture
*p
, Picture
*ref
){
880 for(plane
=0; plane
<3; plane
++){
881 const int stride
= p
->linesize
[plane
];
882 const int bw
= plane
? 1 : 2;
883 for(y
=0; y
<s
->mb_height
*bw
; y
++){
884 for(x
=0; x
<s
->mb_width
*bw
; x
++){
885 int off
= p
->type
== FF_BUFFER_TYPE_SHARED
? 0: 16;
886 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);
888 switch(s
->avctx
->frame_skip_exp
){
889 case 0: score
= FFMAX(score
, v
); break;
890 case 1: score
+= FFABS(v
);break;
891 case 2: score
+= v
*v
;break;
892 case 3: score64
+= FFABS(v
*v
*(int64_t)v
);break;
893 case 4: score64
+= v
*v
*(int64_t)(v
*v
);break;
899 if(score
) score64
= score
;
901 if(score64
< s
->avctx
->frame_skip_threshold
)
903 if(score64
< ((s
->avctx
->frame_skip_factor
* (int64_t)s
->lambda
)>>8))
908 static int estimate_best_b_count(MpegEncContext
*s
){
909 AVCodec
*codec
= avcodec_find_encoder(s
->avctx
->codec_id
);
910 AVCodecContext
*c
= avcodec_alloc_context();
911 AVFrame input
[FF_MAX_B_FRAMES
+2];
912 const int scale
= s
->avctx
->brd_scale
;
913 int i
, j
, out_size
, p_lambda
, b_lambda
, lambda2
;
914 int outbuf_size
= s
->width
* s
->height
; //FIXME
915 uint8_t *outbuf
= av_malloc(outbuf_size
);
916 int64_t best_rd
= INT64_MAX
;
917 int best_b_count
= -1;
919 assert(scale
>=0 && scale
<=3);
922 p_lambda
= s
->last_lambda_for
[FF_P_TYPE
]; //s->next_picture_ptr->quality;
923 b_lambda
= s
->last_lambda_for
[FF_B_TYPE
]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
924 if(!b_lambda
) b_lambda
= p_lambda
; //FIXME we should do this somewhere else
925 lambda2
= (b_lambda
*b_lambda
+ (1<<FF_LAMBDA_SHIFT
)/2 ) >> FF_LAMBDA_SHIFT
;
927 c
->width
= s
->width
>> scale
;
928 c
->height
= s
->height
>> scale
;
929 c
->flags
= CODEC_FLAG_QSCALE
| CODEC_FLAG_PSNR
| CODEC_FLAG_INPUT_PRESERVED
/*| CODEC_FLAG_EMU_EDGE*/;
930 c
->flags
|= s
->avctx
->flags
& CODEC_FLAG_QPEL
;
931 c
->mb_decision
= s
->avctx
->mb_decision
;
932 c
->me_cmp
= s
->avctx
->me_cmp
;
933 c
->mb_cmp
= s
->avctx
->mb_cmp
;
934 c
->me_sub_cmp
= s
->avctx
->me_sub_cmp
;
935 c
->pix_fmt
= PIX_FMT_YUV420P
;
936 c
->time_base
= s
->avctx
->time_base
;
937 c
->max_b_frames
= s
->max_b_frames
;
939 if (avcodec_open(c
, codec
) < 0)
942 for(i
=0; i
<s
->max_b_frames
+2; i
++){
943 int ysize
= c
->width
*c
->height
;
944 int csize
= (c
->width
/2)*(c
->height
/2);
945 Picture pre_input
, *pre_input_ptr
= i
? s
->input_picture
[i
-1] : s
->next_picture_ptr
;
947 avcodec_get_frame_defaults(&input
[i
]);
948 input
[i
].data
[0]= av_malloc(ysize
+ 2*csize
);
949 input
[i
].data
[1]= input
[i
].data
[0] + ysize
;
950 input
[i
].data
[2]= input
[i
].data
[1] + csize
;
951 input
[i
].linesize
[0]= c
->width
;
952 input
[i
].linesize
[1]=
953 input
[i
].linesize
[2]= c
->width
/2;
955 if(pre_input_ptr
&& (!i
|| s
->input_picture
[i
-1])) {
956 pre_input
= *pre_input_ptr
;
958 if(pre_input
.type
!= FF_BUFFER_TYPE_SHARED
&& i
) {
959 pre_input
.data
[0]+=INPLACE_OFFSET
;
960 pre_input
.data
[1]+=INPLACE_OFFSET
;
961 pre_input
.data
[2]+=INPLACE_OFFSET
;
964 s
->dsp
.shrink
[scale
](input
[i
].data
[0], input
[i
].linesize
[0], pre_input
.data
[0], pre_input
.linesize
[0], c
->width
, c
->height
);
965 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);
966 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);
970 for(j
=0; j
<s
->max_b_frames
+1; j
++){
973 if(!s
->input_picture
[j
])
976 c
->error
[0]= c
->error
[1]= c
->error
[2]= 0;
978 input
[0].pict_type
= FF_I_TYPE
;
979 input
[0].quality
= 1 * FF_QP2LAMBDA
;
980 out_size
= avcodec_encode_video(c
, outbuf
, outbuf_size
, &input
[0]);
981 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
983 for(i
=0; i
<s
->max_b_frames
+1; i
++){
984 int is_p
= i
% (j
+1) == j
|| i
==s
->max_b_frames
;
986 input
[i
+1].pict_type
= is_p
? FF_P_TYPE
: FF_B_TYPE
;
987 input
[i
+1].quality
= is_p
? p_lambda
: b_lambda
;
988 out_size
= avcodec_encode_video(c
, outbuf
, outbuf_size
, &input
[i
+1]);
989 rd
+= (out_size
* lambda2
) >> (FF_LAMBDA_SHIFT
- 3);
992 /* get the delayed frames */
994 out_size
= avcodec_encode_video(c
, outbuf
, outbuf_size
, NULL
);
995 rd
+= (out_size
* lambda2
) >> (FF_LAMBDA_SHIFT
- 3);
998 rd
+= c
->error
[0] + c
->error
[1] + c
->error
[2];
1010 for(i
=0; i
<s
->max_b_frames
+2; i
++){
1011 av_freep(&input
[i
].data
[0]);
1014 return best_b_count
;
1017 static void select_input_picture(MpegEncContext
*s
){
1020 for(i
=1; i
<MAX_PICTURE_COUNT
; i
++)
1021 s
->reordered_input_picture
[i
-1]= s
->reordered_input_picture
[i
];
1022 s
->reordered_input_picture
[MAX_PICTURE_COUNT
-1]= NULL
;
1024 /* set next picture type & ordering */
1025 if(s
->reordered_input_picture
[0]==NULL
&& s
->input_picture
[0]){
1026 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s
->next_picture_ptr
==NULL
|| s
->intra_only
){
1027 s
->reordered_input_picture
[0]= s
->input_picture
[0];
1028 s
->reordered_input_picture
[0]->pict_type
= FF_I_TYPE
;
1029 s
->reordered_input_picture
[0]->coded_picture_number
= s
->coded_picture_number
++;
1033 if(s
->avctx
->frame_skip_threshold
|| s
->avctx
->frame_skip_factor
){
1034 if(s
->picture_in_gop_number
< s
->gop_size
&& skip_check(s
, s
->input_picture
[0], s
->next_picture_ptr
)){
1035 //FIXME check that te gop check above is +-1 correct
1036 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
1038 if(s
->input_picture
[0]->type
== FF_BUFFER_TYPE_SHARED
){
1040 s
->input_picture
[0]->data
[i
]= NULL
;
1041 s
->input_picture
[0]->type
= 0;
1043 assert( s
->input_picture
[0]->type
==FF_BUFFER_TYPE_USER
1044 || s
->input_picture
[0]->type
==FF_BUFFER_TYPE_INTERNAL
);
1046 s
->avctx
->release_buffer(s
->avctx
, (AVFrame
*)s
->input_picture
[0]);
1050 ff_vbv_update(s
, 0);
1056 if(s
->flags
&CODEC_FLAG_PASS2
){
1057 for(i
=0; i
<s
->max_b_frames
+1; i
++){
1058 int pict_num
= s
->input_picture
[0]->display_picture_number
+ i
;
1060 if(pict_num
>= s
->rc_context
.num_entries
)
1062 if(!s
->input_picture
[i
]){
1063 s
->rc_context
.entry
[pict_num
-1].new_pict_type
= FF_P_TYPE
;
1067 s
->input_picture
[i
]->pict_type
=
1068 s
->rc_context
.entry
[pict_num
].new_pict_type
;
1072 if(s
->avctx
->b_frame_strategy
==0){
1073 b_frames
= s
->max_b_frames
;
1074 while(b_frames
&& !s
->input_picture
[b_frames
]) b_frames
--;
1075 }else if(s
->avctx
->b_frame_strategy
==1){
1076 for(i
=1; i
<s
->max_b_frames
+1; i
++){
1077 if(s
->input_picture
[i
] && s
->input_picture
[i
]->b_frame_score
==0){
1078 s
->input_picture
[i
]->b_frame_score
=
1079 get_intra_count(s
, s
->input_picture
[i
]->data
[0],
1080 s
->input_picture
[i
-1]->data
[0], s
->linesize
) + 1;
1083 for(i
=0; i
<s
->max_b_frames
+1; i
++){
1084 if(s
->input_picture
[i
]==NULL
|| s
->input_picture
[i
]->b_frame_score
- 1 > s
->mb_num
/s
->avctx
->b_sensitivity
) break;
1087 b_frames
= FFMAX(0, i
-1);
1090 for(i
=0; i
<b_frames
+1; i
++){
1091 s
->input_picture
[i
]->b_frame_score
=0;
1093 }else if(s
->avctx
->b_frame_strategy
==2){
1094 b_frames
= estimate_best_b_count(s
);
1096 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal b frame strategy\n");
1101 //static int b_count=0;
1102 //b_count+= b_frames;
1103 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1105 for(i
= b_frames
- 1; i
>=0; i
--){
1106 int type
= s
->input_picture
[i
]->pict_type
;
1107 if(type
&& type
!= FF_B_TYPE
)
1110 if(s
->input_picture
[b_frames
]->pict_type
== FF_B_TYPE
&& b_frames
== s
->max_b_frames
){
1111 av_log(s
->avctx
, AV_LOG_ERROR
, "warning, too many b frames in a row\n");
1114 if(s
->picture_in_gop_number
+ b_frames
>= s
->gop_size
){
1115 if((s
->flags2
& CODEC_FLAG2_STRICT_GOP
) && s
->gop_size
> s
->picture_in_gop_number
){
1116 b_frames
= s
->gop_size
- s
->picture_in_gop_number
- 1;
1118 if(s
->flags
& CODEC_FLAG_CLOSED_GOP
)
1120 s
->input_picture
[b_frames
]->pict_type
= FF_I_TYPE
;
1124 if( (s
->flags
& CODEC_FLAG_CLOSED_GOP
)
1126 && s
->input_picture
[b_frames
]->pict_type
== FF_I_TYPE
)
1129 s
->reordered_input_picture
[0]= s
->input_picture
[b_frames
];
1130 if(s
->reordered_input_picture
[0]->pict_type
!= FF_I_TYPE
)
1131 s
->reordered_input_picture
[0]->pict_type
= FF_P_TYPE
;
1132 s
->reordered_input_picture
[0]->coded_picture_number
= s
->coded_picture_number
++;
1133 for(i
=0; i
<b_frames
; i
++){
1134 s
->reordered_input_picture
[i
+1]= s
->input_picture
[i
];
1135 s
->reordered_input_picture
[i
+1]->pict_type
= FF_B_TYPE
;
1136 s
->reordered_input_picture
[i
+1]->coded_picture_number
= s
->coded_picture_number
++;
1141 if(s
->reordered_input_picture
[0]){
1142 s
->reordered_input_picture
[0]->reference
= s
->reordered_input_picture
[0]->pict_type
!=FF_B_TYPE
? 3 : 0;
1144 ff_copy_picture(&s
->new_picture
, s
->reordered_input_picture
[0]);
1146 if(s
->reordered_input_picture
[0]->type
== FF_BUFFER_TYPE_SHARED
|| s
->avctx
->rc_buffer_size
){
1147 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
1149 int i
= ff_find_unused_picture(s
, 0);
1150 Picture
*pic
= &s
->picture
[i
];
1152 pic
->reference
= s
->reordered_input_picture
[0]->reference
;
1153 ff_alloc_picture(s
, pic
, 0);
1155 /* mark us unused / free shared pic */
1156 if(s
->reordered_input_picture
[0]->type
== FF_BUFFER_TYPE_INTERNAL
)
1157 s
->avctx
->release_buffer(s
->avctx
, (AVFrame
*)s
->reordered_input_picture
[0]);
1159 s
->reordered_input_picture
[0]->data
[i
]= NULL
;
1160 s
->reordered_input_picture
[0]->type
= 0;
1162 copy_picture_attributes(s
, (AVFrame
*)pic
, (AVFrame
*)s
->reordered_input_picture
[0]);
1164 s
->current_picture_ptr
= pic
;
1166 // input is not a shared pix -> reuse buffer for current_pix
1168 assert( s
->reordered_input_picture
[0]->type
==FF_BUFFER_TYPE_USER
1169 || s
->reordered_input_picture
[0]->type
==FF_BUFFER_TYPE_INTERNAL
);
1171 s
->current_picture_ptr
= s
->reordered_input_picture
[0];
1173 s
->new_picture
.data
[i
]+= INPLACE_OFFSET
;
1176 ff_copy_picture(&s
->current_picture
, s
->current_picture_ptr
);
1178 s
->picture_number
= s
->new_picture
.display_picture_number
;
1179 //printf("dpn:%d\n", s->picture_number);
1181 memset(&s
->new_picture
, 0, sizeof(Picture
));
1185 int MPV_encode_picture(AVCodecContext
*avctx
,
1186 unsigned char *buf
, int buf_size
, void *data
)
1188 MpegEncContext
*s
= avctx
->priv_data
;
1189 AVFrame
*pic_arg
= data
;
1190 int i
, stuffing_count
;
1192 for(i
=0; i
<avctx
->thread_count
; i
++){
1193 int start_y
= s
->thread_context
[i
]->start_mb_y
;
1194 int end_y
= s
->thread_context
[i
]-> end_mb_y
;
1195 int h
= s
->mb_height
;
1196 uint8_t *start
= buf
+ (size_t)(((int64_t) buf_size
)*start_y
/h
);
1197 uint8_t *end
= buf
+ (size_t)(((int64_t) buf_size
)* end_y
/h
);
1199 init_put_bits(&s
->thread_context
[i
]->pb
, start
, end
- start
);
1202 s
->picture_in_gop_number
++;
1204 if(load_input_picture(s
, pic_arg
) < 0)
1207 select_input_picture(s
);
1210 if(s
->new_picture
.data
[0]){
1211 s
->pict_type
= s
->new_picture
.pict_type
;
1213 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1214 MPV_frame_start(s
, avctx
);
1216 if (encode_picture(s
, s
->picture_number
) < 0)
1219 avctx
->header_bits
= s
->header_bits
;
1220 avctx
->mv_bits
= s
->mv_bits
;
1221 avctx
->misc_bits
= s
->misc_bits
;
1222 avctx
->i_tex_bits
= s
->i_tex_bits
;
1223 avctx
->p_tex_bits
= s
->p_tex_bits
;
1224 avctx
->i_count
= s
->i_count
;
1225 avctx
->p_count
= s
->mb_num
- s
->i_count
- s
->skip_count
; //FIXME f/b_count in avctx
1226 avctx
->skip_count
= s
->skip_count
;
1230 if (CONFIG_MJPEG_ENCODER
&& s
->out_format
== FMT_MJPEG
)
1231 ff_mjpeg_encode_picture_trailer(s
);
1233 if(avctx
->rc_buffer_size
){
1234 RateControlContext
*rcc
= &s
->rc_context
;
1235 int max_size
= rcc
->buffer_index
* avctx
->rc_max_available_vbv_use
;
1237 if(put_bits_count(&s
->pb
) > max_size
&& s
->lambda
< s
->avctx
->lmax
){
1238 s
->next_lambda
= FFMAX(s
->lambda
+1, s
->lambda
*(s
->qscale
+1) / s
->qscale
);
1239 if(s
->adaptive_quant
){
1241 for(i
=0; i
<s
->mb_height
*s
->mb_stride
; i
++)
1242 s
->lambda_table
[i
]= FFMAX(s
->lambda_table
[i
]+1, s
->lambda_table
[i
]*(s
->qscale
+1) / s
->qscale
);
1244 s
->mb_skipped
= 0; //done in MPV_frame_start()
1245 if(s
->pict_type
==FF_P_TYPE
){ //done in encode_picture() so we must undo it
1246 if(s
->flipflop_rounding
|| s
->codec_id
== CODEC_ID_H263P
|| s
->codec_id
== CODEC_ID_MPEG4
)
1247 s
->no_rounding
^= 1;
1249 if(s
->pict_type
!=FF_B_TYPE
){
1250 s
->time_base
= s
->last_time_base
;
1251 s
->last_non_b_time
= s
->time
- s
->pp_time
;
1253 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1254 for(i
=0; i
<avctx
->thread_count
; i
++){
1255 PutBitContext
*pb
= &s
->thread_context
[i
]->pb
;
1256 init_put_bits(pb
, pb
->buf
, pb
->buf_end
- pb
->buf
);
1261 assert(s
->avctx
->rc_max_rate
);
1264 if(s
->flags
&CODEC_FLAG_PASS1
)
1265 ff_write_pass1_stats(s
);
1268 s
->current_picture_ptr
->error
[i
]= s
->current_picture
.error
[i
];
1269 avctx
->error
[i
] += s
->current_picture_ptr
->error
[i
];
1272 if(s
->flags
&CODEC_FLAG_PASS1
)
1273 assert(avctx
->header_bits
+ avctx
->mv_bits
+ avctx
->misc_bits
+ avctx
->i_tex_bits
+ avctx
->p_tex_bits
== put_bits_count(&s
->pb
));
1274 flush_put_bits(&s
->pb
);
1275 s
->frame_bits
= put_bits_count(&s
->pb
);
1277 stuffing_count
= ff_vbv_update(s
, s
->frame_bits
);
1279 if(s
->pb
.buf_end
- s
->pb
.buf
- (put_bits_count(&s
->pb
)>>3) < stuffing_count
+ 50){
1280 av_log(s
->avctx
, AV_LOG_ERROR
, "stuffing too large\n");
1284 switch(s
->codec_id
){
1285 case CODEC_ID_MPEG1VIDEO
:
1286 case CODEC_ID_MPEG2VIDEO
:
1287 while(stuffing_count
--){
1288 put_bits(&s
->pb
, 8, 0);
1291 case CODEC_ID_MPEG4
:
1292 put_bits(&s
->pb
, 16, 0);
1293 put_bits(&s
->pb
, 16, 0x1C3);
1294 stuffing_count
-= 4;
1295 while(stuffing_count
--){
1296 put_bits(&s
->pb
, 8, 0xFF);
1300 av_log(s
->avctx
, AV_LOG_ERROR
, "vbv buffer overflow\n");
1302 flush_put_bits(&s
->pb
);
1303 s
->frame_bits
= put_bits_count(&s
->pb
);
1306 /* update mpeg1/2 vbv_delay for CBR */
1307 if(s
->avctx
->rc_max_rate
&& s
->avctx
->rc_min_rate
== s
->avctx
->rc_max_rate
&& s
->out_format
== FMT_MPEG1
1308 && 90000LL * (avctx
->rc_buffer_size
-1) <= s
->avctx
->rc_max_rate
*0xFFFFLL
){
1309 int vbv_delay
, min_delay
;
1310 double inbits
= s
->avctx
->rc_max_rate
*av_q2d(s
->avctx
->time_base
);
1311 int minbits
= s
->frame_bits
- 8*(s
->vbv_delay_ptr
- s
->pb
.buf
- 1);
1312 double bits
= s
->rc_context
.buffer_index
+ minbits
- inbits
;
1315 av_log(s
->avctx
, AV_LOG_ERROR
, "Internal error, negative bits\n");
1317 assert(s
->repeat_first_field
==0);
1319 vbv_delay
= bits
* 90000 / s
->avctx
->rc_max_rate
;
1320 min_delay
= (minbits
* 90000LL + s
->avctx
->rc_max_rate
- 1)/ s
->avctx
->rc_max_rate
;
1322 vbv_delay
= FFMAX(vbv_delay
, min_delay
);
1324 assert(vbv_delay
< 0xFFFF);
1326 s
->vbv_delay_ptr
[0] &= 0xF8;
1327 s
->vbv_delay_ptr
[0] |= vbv_delay
>>13;
1328 s
->vbv_delay_ptr
[1] = vbv_delay
>>5;
1329 s
->vbv_delay_ptr
[2] &= 0x07;
1330 s
->vbv_delay_ptr
[2] |= vbv_delay
<<3;
1332 s
->total_bits
+= s
->frame_bits
;
1333 avctx
->frame_bits
= s
->frame_bits
;
1335 assert((put_bits_ptr(&s
->pb
) == s
->pb
.buf
));
1338 assert((s
->frame_bits
&7)==0);
1340 return s
->frame_bits
/8;
1343 static inline void dct_single_coeff_elimination(MpegEncContext
*s
, int n
, int threshold
)
1345 static const char tab
[64]=
1357 DCTELEM
*block
= s
->block
[n
];
1358 const int last_index
= s
->block_last_index
[n
];
1363 threshold
= -threshold
;
1367 /* Are all we could set to zero already zero? */
1368 if(last_index
<=skip_dc
- 1) return;
1370 for(i
=0; i
<=last_index
; i
++){
1371 const int j
= s
->intra_scantable
.permutated
[i
];
1372 const int level
= FFABS(block
[j
]);
1374 if(skip_dc
&& i
==0) continue;
1383 if(score
>= threshold
) return;
1384 for(i
=skip_dc
; i
<=last_index
; i
++){
1385 const int j
= s
->intra_scantable
.permutated
[i
];
1388 if(block
[0]) s
->block_last_index
[n
]= 0;
1389 else s
->block_last_index
[n
]= -1;
1392 static inline void clip_coeffs(MpegEncContext
*s
, DCTELEM
*block
, int last_index
)
1395 const int maxlevel
= s
->max_qcoeff
;
1396 const int minlevel
= s
->min_qcoeff
;
1400 i
=1; //skip clipping of intra dc
1404 for(;i
<=last_index
; i
++){
1405 const int j
= s
->intra_scantable
.permutated
[i
];
1406 int level
= block
[j
];
1408 if (level
>maxlevel
){
1411 }else if(level
<minlevel
){
1419 if(overflow
&& s
->avctx
->mb_decision
== FF_MB_DECISION_SIMPLE
)
1420 av_log(s
->avctx
, AV_LOG_INFO
, "warning, clipping %d dct coefficients to %d..%d\n", overflow
, minlevel
, maxlevel
);
1423 static void get_visual_weight(int16_t *weight
, uint8_t *ptr
, int stride
){
1433 for(y2
= FFMAX(y
-1, 0); y2
< FFMIN(8, y
+2); y2
++){
1434 for(x2
= FFMAX(x
-1, 0); x2
< FFMIN(8, x
+2); x2
++){
1435 int v
= ptr
[x2
+ y2
*stride
];
1441 weight
[x
+ 8*y
]= (36*ff_sqrt(count
*sqr
- sum
*sum
)) / count
;
1446 static av_always_inline
void encode_mb_internal(MpegEncContext
*s
, int motion_x
, int motion_y
, int mb_block_height
, int mb_block_count
)
1448 int16_t weight
[8][64];
1449 DCTELEM orig
[8][64];
1450 const int mb_x
= s
->mb_x
;
1451 const int mb_y
= s
->mb_y
;
1454 int dct_offset
= s
->linesize
*8; //default for progressive frames
1455 uint8_t *ptr_y
, *ptr_cb
, *ptr_cr
;
1458 for(i
=0; i
<mb_block_count
; i
++) skip_dct
[i
]=s
->skipdct
;
1460 if(s
->adaptive_quant
){
1461 const int last_qp
= s
->qscale
;
1462 const int mb_xy
= mb_x
+ mb_y
*s
->mb_stride
;
1464 s
->lambda
= s
->lambda_table
[mb_xy
];
1467 if(!(s
->flags
&CODEC_FLAG_QP_RD
)){
1468 s
->qscale
= s
->current_picture_ptr
->qscale_table
[mb_xy
];
1469 s
->dquant
= s
->qscale
- last_qp
;
1471 if(s
->out_format
==FMT_H263
){
1472 s
->dquant
= av_clip(s
->dquant
, -2, 2);
1474 if(s
->codec_id
==CODEC_ID_MPEG4
){
1476 if(s
->pict_type
== FF_B_TYPE
){
1477 if(s
->dquant
&1 || s
->mv_dir
&MV_DIRECT
)
1480 if(s
->mv_type
==MV_TYPE_8X8
)
1486 ff_set_qscale(s
, last_qp
+ s
->dquant
);
1487 }else if(s
->flags
&CODEC_FLAG_QP_RD
)
1488 ff_set_qscale(s
, s
->qscale
+ s
->dquant
);
1490 wrap_y
= s
->linesize
;
1491 wrap_c
= s
->uvlinesize
;
1492 ptr_y
= s
->new_picture
.data
[0] + (mb_y
* 16 * wrap_y
) + mb_x
* 16;
1493 ptr_cb
= s
->new_picture
.data
[1] + (mb_y
* mb_block_height
* wrap_c
) + mb_x
* 8;
1494 ptr_cr
= s
->new_picture
.data
[2] + (mb_y
* mb_block_height
* wrap_c
) + mb_x
* 8;
1496 if(mb_x
*16+16 > s
->width
|| mb_y
*16+16 > s
->height
){
1497 uint8_t *ebuf
= s
->edge_emu_buffer
+ 32;
1498 ff_emulated_edge_mc(ebuf
, ptr_y
, wrap_y
,16,16,mb_x
*16,mb_y
*16, s
->width
, s
->height
);
1500 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);
1501 ptr_cb
= ebuf
+18*wrap_y
;
1502 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);
1503 ptr_cr
= ebuf
+18*wrap_y
+8;
1507 if(s
->flags
&CODEC_FLAG_INTERLACED_DCT
){
1508 int progressive_score
, interlaced_score
;
1510 s
->interlaced_dct
=0;
1511 progressive_score
= s
->dsp
.ildct_cmp
[4](s
, ptr_y
, NULL
, wrap_y
, 8)
1512 +s
->dsp
.ildct_cmp
[4](s
, ptr_y
+ wrap_y
*8, NULL
, wrap_y
, 8) - 400;
1514 if(progressive_score
> 0){
1515 interlaced_score
= s
->dsp
.ildct_cmp
[4](s
, ptr_y
, NULL
, wrap_y
*2, 8)
1516 +s
->dsp
.ildct_cmp
[4](s
, ptr_y
+ wrap_y
, NULL
, wrap_y
*2, 8);
1517 if(progressive_score
> interlaced_score
){
1518 s
->interlaced_dct
=1;
1522 if (s
->chroma_format
== CHROMA_422
)
1528 s
->dsp
.get_pixels(s
->block
[0], ptr_y
, wrap_y
);
1529 s
->dsp
.get_pixels(s
->block
[1], ptr_y
+ 8, wrap_y
);
1530 s
->dsp
.get_pixels(s
->block
[2], ptr_y
+ dct_offset
, wrap_y
);
1531 s
->dsp
.get_pixels(s
->block
[3], ptr_y
+ dct_offset
+ 8, wrap_y
);
1533 if(s
->flags
&CODEC_FLAG_GRAY
){
1537 s
->dsp
.get_pixels(s
->block
[4], ptr_cb
, wrap_c
);
1538 s
->dsp
.get_pixels(s
->block
[5], ptr_cr
, wrap_c
);
1539 if(!s
->chroma_y_shift
){ /* 422 */
1540 s
->dsp
.get_pixels(s
->block
[6], ptr_cb
+ (dct_offset
>>1), wrap_c
);
1541 s
->dsp
.get_pixels(s
->block
[7], ptr_cr
+ (dct_offset
>>1), wrap_c
);
1545 op_pixels_func (*op_pix
)[4];
1546 qpel_mc_func (*op_qpix
)[16];
1547 uint8_t *dest_y
, *dest_cb
, *dest_cr
;
1549 dest_y
= s
->dest
[0];
1550 dest_cb
= s
->dest
[1];
1551 dest_cr
= s
->dest
[2];
1553 if ((!s
->no_rounding
) || s
->pict_type
==FF_B_TYPE
){
1554 op_pix
= s
->dsp
.put_pixels_tab
;
1555 op_qpix
= s
->dsp
.put_qpel_pixels_tab
;
1557 op_pix
= s
->dsp
.put_no_rnd_pixels_tab
;
1558 op_qpix
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
1561 if (s
->mv_dir
& MV_DIR_FORWARD
) {
1562 MPV_motion(s
, dest_y
, dest_cb
, dest_cr
, 0, s
->last_picture
.data
, op_pix
, op_qpix
);
1563 op_pix
= s
->dsp
.avg_pixels_tab
;
1564 op_qpix
= s
->dsp
.avg_qpel_pixels_tab
;
1566 if (s
->mv_dir
& MV_DIR_BACKWARD
) {
1567 MPV_motion(s
, dest_y
, dest_cb
, dest_cr
, 1, s
->next_picture
.data
, op_pix
, op_qpix
);
1570 if(s
->flags
&CODEC_FLAG_INTERLACED_DCT
){
1571 int progressive_score
, interlaced_score
;
1573 s
->interlaced_dct
=0;
1574 progressive_score
= s
->dsp
.ildct_cmp
[0](s
, dest_y
, ptr_y
, wrap_y
, 8)
1575 +s
->dsp
.ildct_cmp
[0](s
, dest_y
+ wrap_y
*8, ptr_y
+ wrap_y
*8, wrap_y
, 8) - 400;
1577 if(s
->avctx
->ildct_cmp
== FF_CMP_VSSE
) progressive_score
-= 400;
1579 if(progressive_score
>0){
1580 interlaced_score
= s
->dsp
.ildct_cmp
[0](s
, dest_y
, ptr_y
, wrap_y
*2, 8)
1581 +s
->dsp
.ildct_cmp
[0](s
, dest_y
+ wrap_y
, ptr_y
+ wrap_y
, wrap_y
*2, 8);
1583 if(progressive_score
> interlaced_score
){
1584 s
->interlaced_dct
=1;
1588 if (s
->chroma_format
== CHROMA_422
)
1594 s
->dsp
.diff_pixels(s
->block
[0], ptr_y
, dest_y
, wrap_y
);
1595 s
->dsp
.diff_pixels(s
->block
[1], ptr_y
+ 8, dest_y
+ 8, wrap_y
);
1596 s
->dsp
.diff_pixels(s
->block
[2], ptr_y
+ dct_offset
, dest_y
+ dct_offset
, wrap_y
);
1597 s
->dsp
.diff_pixels(s
->block
[3], ptr_y
+ dct_offset
+ 8, dest_y
+ dct_offset
+ 8, wrap_y
);
1599 if(s
->flags
&CODEC_FLAG_GRAY
){
1603 s
->dsp
.diff_pixels(s
->block
[4], ptr_cb
, dest_cb
, wrap_c
);
1604 s
->dsp
.diff_pixels(s
->block
[5], ptr_cr
, dest_cr
, wrap_c
);
1605 if(!s
->chroma_y_shift
){ /* 422 */
1606 s
->dsp
.diff_pixels(s
->block
[6], ptr_cb
+ (dct_offset
>>1), dest_cb
+ (dct_offset
>>1), wrap_c
);
1607 s
->dsp
.diff_pixels(s
->block
[7], ptr_cr
+ (dct_offset
>>1), dest_cr
+ (dct_offset
>>1), wrap_c
);
1610 /* pre quantization */
1611 if(s
->current_picture
.mc_mb_var
[s
->mb_stride
*mb_y
+ mb_x
]<2*s
->qscale
*s
->qscale
){
1613 if(s
->dsp
.sad
[1](NULL
, ptr_y
, dest_y
, wrap_y
, 8) < 20*s
->qscale
) skip_dct
[0]= 1;
1614 if(s
->dsp
.sad
[1](NULL
, ptr_y
+ 8, dest_y
+ 8, wrap_y
, 8) < 20*s
->qscale
) skip_dct
[1]= 1;
1615 if(s
->dsp
.sad
[1](NULL
, ptr_y
+dct_offset
, dest_y
+dct_offset
, wrap_y
, 8) < 20*s
->qscale
) skip_dct
[2]= 1;
1616 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;
1617 if(s
->dsp
.sad
[1](NULL
, ptr_cb
, dest_cb
, wrap_c
, 8) < 20*s
->qscale
) skip_dct
[4]= 1;
1618 if(s
->dsp
.sad
[1](NULL
, ptr_cr
, dest_cr
, wrap_c
, 8) < 20*s
->qscale
) skip_dct
[5]= 1;
1619 if(!s
->chroma_y_shift
){ /* 422 */
1620 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;
1621 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;
1626 if(s
->avctx
->quantizer_noise_shaping
){
1627 if(!skip_dct
[0]) get_visual_weight(weight
[0], ptr_y
, wrap_y
);
1628 if(!skip_dct
[1]) get_visual_weight(weight
[1], ptr_y
+ 8, wrap_y
);
1629 if(!skip_dct
[2]) get_visual_weight(weight
[2], ptr_y
+ dct_offset
, wrap_y
);
1630 if(!skip_dct
[3]) get_visual_weight(weight
[3], ptr_y
+ dct_offset
+ 8, wrap_y
);
1631 if(!skip_dct
[4]) get_visual_weight(weight
[4], ptr_cb
, wrap_c
);
1632 if(!skip_dct
[5]) get_visual_weight(weight
[5], ptr_cr
, wrap_c
);
1633 if(!s
->chroma_y_shift
){ /* 422 */
1634 if(!skip_dct
[6]) get_visual_weight(weight
[6], ptr_cb
+ (dct_offset
>>1), wrap_c
);
1635 if(!skip_dct
[7]) get_visual_weight(weight
[7], ptr_cr
+ (dct_offset
>>1), wrap_c
);
1637 memcpy(orig
[0], s
->block
[0], sizeof(DCTELEM
)*64*mb_block_count
);
1640 /* DCT & quantize */
1641 assert(s
->out_format
!=FMT_MJPEG
|| s
->qscale
==8);
1643 for(i
=0;i
<mb_block_count
;i
++) {
1646 s
->block_last_index
[i
] = s
->dct_quantize(s
, s
->block
[i
], i
, s
->qscale
, &overflow
);
1647 // FIXME we could decide to change to quantizer instead of clipping
1648 // JS: I don't think that would be a good idea it could lower quality instead
1649 // of improve it. Just INTRADC clipping deserves changes in quantizer
1650 if (overflow
) clip_coeffs(s
, s
->block
[i
], s
->block_last_index
[i
]);
1652 s
->block_last_index
[i
]= -1;
1654 if(s
->avctx
->quantizer_noise_shaping
){
1655 for(i
=0;i
<mb_block_count
;i
++) {
1657 s
->block_last_index
[i
] = dct_quantize_refine(s
, s
->block
[i
], weight
[i
], orig
[i
], i
, s
->qscale
);
1662 if(s
->luma_elim_threshold
&& !s
->mb_intra
)
1664 dct_single_coeff_elimination(s
, i
, s
->luma_elim_threshold
);
1665 if(s
->chroma_elim_threshold
&& !s
->mb_intra
)
1666 for(i
=4; i
<mb_block_count
; i
++)
1667 dct_single_coeff_elimination(s
, i
, s
->chroma_elim_threshold
);
1669 if(s
->flags
& CODEC_FLAG_CBP_RD
){
1670 for(i
=0;i
<mb_block_count
;i
++) {
1671 if(s
->block_last_index
[i
] == -1)
1672 s
->coded_score
[i
]= INT_MAX
/256;
1677 if((s
->flags
&CODEC_FLAG_GRAY
) && s
->mb_intra
){
1678 s
->block_last_index
[4]=
1679 s
->block_last_index
[5]= 0;
1681 s
->block
[5][0]= (1024 + s
->c_dc_scale
/2)/ s
->c_dc_scale
;
1684 //non c quantize code returns incorrect block_last_index FIXME
1685 if(s
->alternate_scan
&& s
->dct_quantize
!= dct_quantize_c
){
1686 for(i
=0; i
<mb_block_count
; i
++){
1688 if(s
->block_last_index
[i
]>0){
1689 for(j
=63; j
>0; j
--){
1690 if(s
->block
[i
][ s
->intra_scantable
.permutated
[j
] ]) break;
1692 s
->block_last_index
[i
]= j
;
1697 /* huffman encode */
1698 switch(s
->codec_id
){ //FIXME funct ptr could be slightly faster
1699 case CODEC_ID_MPEG1VIDEO
:
1700 case CODEC_ID_MPEG2VIDEO
:
1701 if (CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
)
1702 mpeg1_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1704 case CODEC_ID_MPEG4
:
1705 if (CONFIG_MPEG4_ENCODER
)
1706 mpeg4_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1708 case CODEC_ID_MSMPEG4V2
:
1709 case CODEC_ID_MSMPEG4V3
:
1711 if (CONFIG_MSMPEG4_ENCODER
)
1712 msmpeg4_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1715 if (CONFIG_WMV2_ENCODER
)
1716 ff_wmv2_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1719 if (CONFIG_H261_ENCODER
)
1720 ff_h261_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1723 case CODEC_ID_H263P
:
1727 if (CONFIG_H263_ENCODER
)
1728 h263_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1730 case CODEC_ID_MJPEG
:
1731 if (CONFIG_MJPEG_ENCODER
)
1732 ff_mjpeg_encode_mb(s
, s
->block
);
1739 static av_always_inline
void encode_mb(MpegEncContext
*s
, int motion_x
, int motion_y
)
1741 if (s
->chroma_format
== CHROMA_420
) encode_mb_internal(s
, motion_x
, motion_y
, 8, 6);
1742 else encode_mb_internal(s
, motion_x
, motion_y
, 16, 8);
1745 static inline void copy_context_before_encode(MpegEncContext
*d
, MpegEncContext
*s
, int type
){
1748 memcpy(d
->last_mv
, s
->last_mv
, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1751 d
->mb_skip_run
= s
->mb_skip_run
;
1753 d
->last_dc
[i
]= s
->last_dc
[i
];
1756 d
->mv_bits
= s
->mv_bits
;
1757 d
->i_tex_bits
= s
->i_tex_bits
;
1758 d
->p_tex_bits
= s
->p_tex_bits
;
1759 d
->i_count
= s
->i_count
;
1760 d
->f_count
= s
->f_count
;
1761 d
->b_count
= s
->b_count
;
1762 d
->skip_count
= s
->skip_count
;
1763 d
->misc_bits
= s
->misc_bits
;
1767 d
->qscale
= s
->qscale
;
1768 d
->dquant
= s
->dquant
;
1770 d
->esc3_level_length
= s
->esc3_level_length
;
1773 static inline void copy_context_after_encode(MpegEncContext
*d
, MpegEncContext
*s
, int type
){
1776 memcpy(d
->mv
, s
->mv
, 2*4*2*sizeof(int));
1777 memcpy(d
->last_mv
, s
->last_mv
, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1780 d
->mb_skip_run
= s
->mb_skip_run
;
1782 d
->last_dc
[i
]= s
->last_dc
[i
];
1785 d
->mv_bits
= s
->mv_bits
;
1786 d
->i_tex_bits
= s
->i_tex_bits
;
1787 d
->p_tex_bits
= s
->p_tex_bits
;
1788 d
->i_count
= s
->i_count
;
1789 d
->f_count
= s
->f_count
;
1790 d
->b_count
= s
->b_count
;
1791 d
->skip_count
= s
->skip_count
;
1792 d
->misc_bits
= s
->misc_bits
;
1794 d
->mb_intra
= s
->mb_intra
;
1795 d
->mb_skipped
= s
->mb_skipped
;
1796 d
->mv_type
= s
->mv_type
;
1797 d
->mv_dir
= s
->mv_dir
;
1799 if(s
->data_partitioning
){
1801 d
->tex_pb
= s
->tex_pb
;
1805 d
->block_last_index
[i
]= s
->block_last_index
[i
];
1806 d
->interlaced_dct
= s
->interlaced_dct
;
1807 d
->qscale
= s
->qscale
;
1809 d
->esc3_level_length
= s
->esc3_level_length
;
1812 static inline void encode_mb_hq(MpegEncContext
*s
, MpegEncContext
*backup
, MpegEncContext
*best
, int type
,
1813 PutBitContext pb
[2], PutBitContext pb2
[2], PutBitContext tex_pb
[2],
1814 int *dmin
, int *next_block
, int motion_x
, int motion_y
)
1817 uint8_t *dest_backup
[3];
1819 copy_context_before_encode(s
, backup
, type
);
1821 s
->block
= s
->blocks
[*next_block
];
1822 s
->pb
= pb
[*next_block
];
1823 if(s
->data_partitioning
){
1824 s
->pb2
= pb2
[*next_block
];
1825 s
->tex_pb
= tex_pb
[*next_block
];
1829 memcpy(dest_backup
, s
->dest
, sizeof(s
->dest
));
1830 s
->dest
[0] = s
->rd_scratchpad
;
1831 s
->dest
[1] = s
->rd_scratchpad
+ 16*s
->linesize
;
1832 s
->dest
[2] = s
->rd_scratchpad
+ 16*s
->linesize
+ 8;
1833 assert(s
->linesize
>= 32); //FIXME
1836 encode_mb(s
, motion_x
, motion_y
);
1838 score
= put_bits_count(&s
->pb
);
1839 if(s
->data_partitioning
){
1840 score
+= put_bits_count(&s
->pb2
);
1841 score
+= put_bits_count(&s
->tex_pb
);
1844 if(s
->avctx
->mb_decision
== FF_MB_DECISION_RD
){
1845 MPV_decode_mb(s
, s
->block
);
1847 score
*= s
->lambda2
;
1848 score
+= sse_mb(s
) << FF_LAMBDA_SHIFT
;
1852 memcpy(s
->dest
, dest_backup
, sizeof(s
->dest
));
1859 copy_context_after_encode(best
, s
, type
);
1863 static int sse(MpegEncContext
*s
, uint8_t *src1
, uint8_t *src2
, int w
, int h
, int stride
){
1864 uint32_t *sq
= ff_squareTbl
+ 256;
1869 return s
->dsp
.sse
[0](NULL
, src1
, src2
, stride
, 16);
1870 else if(w
==8 && h
==8)
1871 return s
->dsp
.sse
[1](NULL
, src1
, src2
, stride
, 8);
1875 acc
+= sq
[src1
[x
+ y
*stride
] - src2
[x
+ y
*stride
]];
1884 static int sse_mb(MpegEncContext
*s
){
1888 if(s
->mb_x
*16 + 16 > s
->width
) w
= s
->width
- s
->mb_x
*16;
1889 if(s
->mb_y
*16 + 16 > s
->height
) h
= s
->height
- s
->mb_y
*16;
1892 if(s
->avctx
->mb_cmp
== FF_CMP_NSSE
){
1893 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)
1894 +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)
1895 +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);
1897 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)
1898 +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)
1899 +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);
1902 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
)
1903 +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
)
1904 +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
);
1907 static int pre_estimate_motion_thread(AVCodecContext
*c
, void *arg
){
1908 MpegEncContext
*s
= *(void**)arg
;
1912 s
->me
.dia_size
= s
->avctx
->pre_dia_size
;
1913 s
->first_slice_line
=1;
1914 for(s
->mb_y
= s
->end_mb_y
-1; s
->mb_y
>= s
->start_mb_y
; s
->mb_y
--) {
1915 for(s
->mb_x
=s
->mb_width
-1; s
->mb_x
>=0 ;s
->mb_x
--) {
1916 ff_pre_estimate_p_frame_motion(s
, s
->mb_x
, s
->mb_y
);
1918 s
->first_slice_line
=0;
1926 static int estimate_motion_thread(AVCodecContext
*c
, void *arg
){
1927 MpegEncContext
*s
= *(void**)arg
;
1929 ff_check_alignment();
1931 s
->me
.dia_size
= s
->avctx
->dia_size
;
1932 s
->first_slice_line
=1;
1933 for(s
->mb_y
= s
->start_mb_y
; s
->mb_y
< s
->end_mb_y
; s
->mb_y
++) {
1934 s
->mb_x
=0; //for block init below
1935 ff_init_block_index(s
);
1936 for(s
->mb_x
=0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
1937 s
->block_index
[0]+=2;
1938 s
->block_index
[1]+=2;
1939 s
->block_index
[2]+=2;
1940 s
->block_index
[3]+=2;
1942 /* compute motion vector & mb_type and store in context */
1943 if(s
->pict_type
==FF_B_TYPE
)
1944 ff_estimate_b_frame_motion(s
, s
->mb_x
, s
->mb_y
);
1946 ff_estimate_p_frame_motion(s
, s
->mb_x
, s
->mb_y
);
1948 s
->first_slice_line
=0;
1953 static int mb_var_thread(AVCodecContext
*c
, void *arg
){
1954 MpegEncContext
*s
= *(void**)arg
;
1957 ff_check_alignment();
1959 for(mb_y
=s
->start_mb_y
; mb_y
< s
->end_mb_y
; mb_y
++) {
1960 for(mb_x
=0; mb_x
< s
->mb_width
; mb_x
++) {
1963 uint8_t *pix
= s
->new_picture
.data
[0] + (yy
* s
->linesize
) + xx
;
1965 int sum
= s
->dsp
.pix_sum(pix
, s
->linesize
);
1967 varc
= (s
->dsp
.pix_norm1(pix
, s
->linesize
) - (((unsigned)(sum
*sum
))>>8) + 500 + 128)>>8;
1969 s
->current_picture
.mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = varc
;
1970 s
->current_picture
.mb_mean
[s
->mb_stride
* mb_y
+ mb_x
] = (sum
+128)>>8;
1971 s
->me
.mb_var_sum_temp
+= varc
;
1977 static void write_slice_end(MpegEncContext
*s
){
1978 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
==CODEC_ID_MPEG4
){
1979 if(s
->partitioned_frame
){
1980 ff_mpeg4_merge_partitions(s
);
1983 ff_mpeg4_stuffing(&s
->pb
);
1984 }else if(CONFIG_MJPEG_ENCODER
&& s
->out_format
== FMT_MJPEG
){
1985 ff_mjpeg_encode_stuffing(&s
->pb
);
1988 align_put_bits(&s
->pb
);
1989 flush_put_bits(&s
->pb
);
1991 if((s
->flags
&CODEC_FLAG_PASS1
) && !s
->partitioned_frame
)
1992 s
->misc_bits
+= get_bits_diff(s
);
1995 static int encode_thread(AVCodecContext
*c
, void *arg
){
1996 MpegEncContext
*s
= *(void**)arg
;
1997 int mb_x
, mb_y
, pdif
= 0;
1998 int chr_h
= 16>>s
->chroma_y_shift
;
2000 MpegEncContext best_s
, backup_s
;
2001 uint8_t bit_buf
[2][MAX_MB_BYTES
];
2002 uint8_t bit_buf2
[2][MAX_MB_BYTES
];
2003 uint8_t bit_buf_tex
[2][MAX_MB_BYTES
];
2004 PutBitContext pb
[2], pb2
[2], tex_pb
[2];
2005 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2007 ff_check_alignment();
2010 init_put_bits(&pb
[i
], bit_buf
[i
], MAX_MB_BYTES
);
2011 init_put_bits(&pb2
[i
], bit_buf2
[i
], MAX_MB_BYTES
);
2012 init_put_bits(&tex_pb
[i
], bit_buf_tex
[i
], MAX_MB_BYTES
);
2015 s
->last_bits
= put_bits_count(&s
->pb
);
2026 /* init last dc values */
2027 /* note: quant matrix value (8) is implied here */
2028 s
->last_dc
[i
] = 128 << s
->intra_dc_precision
;
2030 s
->current_picture
.error
[i
] = 0;
2033 memset(s
->last_mv
, 0, sizeof(s
->last_mv
));
2037 switch(s
->codec_id
){
2039 case CODEC_ID_H263P
:
2041 if (CONFIG_H263_ENCODER
)
2042 s
->gob_index
= ff_h263_get_gob_height(s
);
2044 case CODEC_ID_MPEG4
:
2045 if(CONFIG_MPEG4_ENCODER
&& s
->partitioned_frame
)
2046 ff_mpeg4_init_partitions(s
);
2052 s
->first_slice_line
= 1;
2053 s
->ptr_lastgob
= s
->pb
.buf
;
2054 for(mb_y
= s
->start_mb_y
; mb_y
< s
->end_mb_y
; mb_y
++) {
2055 // printf("row %d at %X\n", s->mb_y, (int)s);
2059 ff_set_qscale(s
, s
->qscale
);
2060 ff_init_block_index(s
);
2062 for(mb_x
=0; mb_x
< s
->mb_width
; mb_x
++) {
2063 int xy
= mb_y
*s
->mb_stride
+ mb_x
; // removed const, H261 needs to adjust this
2064 int mb_type
= s
->mb_type
[xy
];
2069 if(s
->pb
.buf_end
- s
->pb
.buf
- (put_bits_count(&s
->pb
)>>3) < MAX_MB_BYTES
){
2070 av_log(s
->avctx
, AV_LOG_ERROR
, "encoded frame too large\n");
2073 if(s
->data_partitioning
){
2074 if( s
->pb2
.buf_end
- s
->pb2
.buf
- (put_bits_count(&s
-> pb2
)>>3) < MAX_MB_BYTES
2075 || s
->tex_pb
.buf_end
- s
->tex_pb
.buf
- (put_bits_count(&s
->tex_pb
)>>3) < MAX_MB_BYTES
){
2076 av_log(s
->avctx
, AV_LOG_ERROR
, "encoded frame too large\n");
2082 s
->mb_y
= mb_y
; // moved into loop, can get changed by H.261
2083 ff_update_block_index(s
);
2085 if(CONFIG_H261_ENCODER
&& s
->codec_id
== CODEC_ID_H261
){
2086 ff_h261_reorder_mb_index(s
);
2087 xy
= s
->mb_y
*s
->mb_stride
+ s
->mb_x
;
2088 mb_type
= s
->mb_type
[xy
];
2091 /* write gob / video packet header */
2093 int current_packet_size
, is_gob_start
;
2095 current_packet_size
= ((put_bits_count(&s
->pb
)+7)>>3) - (s
->ptr_lastgob
- s
->pb
.buf
);
2097 is_gob_start
= s
->avctx
->rtp_payload_size
&& current_packet_size
>= s
->avctx
->rtp_payload_size
&& mb_y
+ mb_x
>0;
2099 if(s
->start_mb_y
== mb_y
&& mb_y
> 0 && mb_x
==0) is_gob_start
=1;
2101 switch(s
->codec_id
){
2103 case CODEC_ID_H263P
:
2104 if(!s
->h263_slice_structured
)
2105 if(s
->mb_x
|| s
->mb_y
%s
->gob_index
) is_gob_start
=0;
2107 case CODEC_ID_MPEG2VIDEO
:
2108 if(s
->mb_x
==0 && s
->mb_y
!=0) is_gob_start
=1;
2109 case CODEC_ID_MPEG1VIDEO
:
2110 if(s
->mb_skip_run
) is_gob_start
=0;
2115 if(s
->start_mb_y
!= mb_y
|| mb_x
!=0){
2118 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
==CODEC_ID_MPEG4
&& s
->partitioned_frame
){
2119 ff_mpeg4_init_partitions(s
);
2123 assert((put_bits_count(&s
->pb
)&7) == 0);
2124 current_packet_size
= put_bits_ptr(&s
->pb
) - s
->ptr_lastgob
;
2126 if(s
->avctx
->error_rate
&& s
->resync_mb_x
+ s
->resync_mb_y
> 0){
2127 int r
= put_bits_count(&s
->pb
)/8 + s
->picture_number
+ 16 + s
->mb_x
+ s
->mb_y
;
2128 int d
= 100 / s
->avctx
->error_rate
;
2130 current_packet_size
=0;
2131 #ifndef ALT_BITSTREAM_WRITER
2132 s
->pb
.buf_ptr
= s
->ptr_lastgob
;
2134 assert(put_bits_ptr(&s
->pb
) == s
->ptr_lastgob
);
2138 if (s
->avctx
->rtp_callback
){
2139 int number_mb
= (mb_y
- s
->resync_mb_y
)*s
->mb_width
+ mb_x
- s
->resync_mb_x
;
2140 s
->avctx
->rtp_callback(s
->avctx
, s
->ptr_lastgob
, current_packet_size
, number_mb
);
2143 switch(s
->codec_id
){
2144 case CODEC_ID_MPEG4
:
2145 if (CONFIG_MPEG4_ENCODER
) {
2146 ff_mpeg4_encode_video_packet_header(s
);
2147 ff_mpeg4_clean_buffers(s
);
2150 case CODEC_ID_MPEG1VIDEO
:
2151 case CODEC_ID_MPEG2VIDEO
:
2152 if (CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
) {
2153 ff_mpeg1_encode_slice_header(s
);
2154 ff_mpeg1_clean_buffers(s
);
2158 case CODEC_ID_H263P
:
2159 if (CONFIG_H263_ENCODER
)
2160 h263_encode_gob_header(s
, mb_y
);
2164 if(s
->flags
&CODEC_FLAG_PASS1
){
2165 int bits
= put_bits_count(&s
->pb
);
2166 s
->misc_bits
+= bits
- s
->last_bits
;
2170 s
->ptr_lastgob
+= current_packet_size
;
2171 s
->first_slice_line
=1;
2172 s
->resync_mb_x
=mb_x
;
2173 s
->resync_mb_y
=mb_y
;
2177 if( (s
->resync_mb_x
== s
->mb_x
)
2178 && s
->resync_mb_y
+1 == s
->mb_y
){
2179 s
->first_slice_line
=0;
2183 s
->dquant
=0; //only for QP_RD
2185 if(mb_type
& (mb_type
-1) || (s
->flags
& CODEC_FLAG_QP_RD
)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
2187 int pb_bits_count
, pb2_bits_count
, tex_pb_bits_count
;
2189 copy_context_before_encode(&backup_s
, s
, -1);
2191 best_s
.data_partitioning
= s
->data_partitioning
;
2192 best_s
.partitioned_frame
= s
->partitioned_frame
;
2193 if(s
->data_partitioning
){
2194 backup_s
.pb2
= s
->pb2
;
2195 backup_s
.tex_pb
= s
->tex_pb
;
2198 if(mb_type
&CANDIDATE_MB_TYPE_INTER
){
2199 s
->mv_dir
= MV_DIR_FORWARD
;
2200 s
->mv_type
= MV_TYPE_16X16
;
2202 s
->mv
[0][0][0] = s
->p_mv_table
[xy
][0];
2203 s
->mv
[0][0][1] = s
->p_mv_table
[xy
][1];
2204 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER
, pb
, pb2
, tex_pb
,
2205 &dmin
, &next_block
, s
->mv
[0][0][0], s
->mv
[0][0][1]);
2207 if(mb_type
&CANDIDATE_MB_TYPE_INTER_I
){
2208 s
->mv_dir
= MV_DIR_FORWARD
;
2209 s
->mv_type
= MV_TYPE_FIELD
;
2212 j
= s
->field_select
[0][i
] = s
->p_field_select_table
[i
][xy
];
2213 s
->mv
[0][i
][0] = s
->p_field_mv_table
[i
][j
][xy
][0];
2214 s
->mv
[0][i
][1] = s
->p_field_mv_table
[i
][j
][xy
][1];
2216 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER_I
, pb
, pb2
, tex_pb
,
2217 &dmin
, &next_block
, 0, 0);
2219 if(mb_type
&CANDIDATE_MB_TYPE_SKIPPED
){
2220 s
->mv_dir
= MV_DIR_FORWARD
;
2221 s
->mv_type
= MV_TYPE_16X16
;
2225 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_SKIPPED
, pb
, pb2
, tex_pb
,
2226 &dmin
, &next_block
, s
->mv
[0][0][0], s
->mv
[0][0][1]);
2228 if(mb_type
&CANDIDATE_MB_TYPE_INTER4V
){
2229 s
->mv_dir
= MV_DIR_FORWARD
;
2230 s
->mv_type
= MV_TYPE_8X8
;
2233 s
->mv
[0][i
][0] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][0];
2234 s
->mv
[0][i
][1] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][1];
2236 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER4V
, pb
, pb2
, tex_pb
,
2237 &dmin
, &next_block
, 0, 0);
2239 if(mb_type
&CANDIDATE_MB_TYPE_FORWARD
){
2240 s
->mv_dir
= MV_DIR_FORWARD
;
2241 s
->mv_type
= MV_TYPE_16X16
;
2243 s
->mv
[0][0][0] = s
->b_forw_mv_table
[xy
][0];
2244 s
->mv
[0][0][1] = s
->b_forw_mv_table
[xy
][1];
2245 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_FORWARD
, pb
, pb2
, tex_pb
,
2246 &dmin
, &next_block
, s
->mv
[0][0][0], s
->mv
[0][0][1]);
2248 if(mb_type
&CANDIDATE_MB_TYPE_BACKWARD
){
2249 s
->mv_dir
= MV_DIR_BACKWARD
;
2250 s
->mv_type
= MV_TYPE_16X16
;
2252 s
->mv
[1][0][0] = s
->b_back_mv_table
[xy
][0];
2253 s
->mv
[1][0][1] = s
->b_back_mv_table
[xy
][1];
2254 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BACKWARD
, pb
, pb2
, tex_pb
,
2255 &dmin
, &next_block
, s
->mv
[1][0][0], s
->mv
[1][0][1]);
2257 if(mb_type
&CANDIDATE_MB_TYPE_BIDIR
){
2258 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2259 s
->mv_type
= MV_TYPE_16X16
;
2261 s
->mv
[0][0][0] = s
->b_bidir_forw_mv_table
[xy
][0];
2262 s
->mv
[0][0][1] = s
->b_bidir_forw_mv_table
[xy
][1];
2263 s
->mv
[1][0][0] = s
->b_bidir_back_mv_table
[xy
][0];
2264 s
->mv
[1][0][1] = s
->b_bidir_back_mv_table
[xy
][1];
2265 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BIDIR
, pb
, pb2
, tex_pb
,
2266 &dmin
, &next_block
, 0, 0);
2268 if(mb_type
&CANDIDATE_MB_TYPE_FORWARD_I
){
2269 s
->mv_dir
= MV_DIR_FORWARD
;
2270 s
->mv_type
= MV_TYPE_FIELD
;
2273 j
= s
->field_select
[0][i
] = s
->b_field_select_table
[0][i
][xy
];
2274 s
->mv
[0][i
][0] = s
->b_field_mv_table
[0][i
][j
][xy
][0];
2275 s
->mv
[0][i
][1] = s
->b_field_mv_table
[0][i
][j
][xy
][1];
2277 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_FORWARD_I
, pb
, pb2
, tex_pb
,
2278 &dmin
, &next_block
, 0, 0);
2280 if(mb_type
&CANDIDATE_MB_TYPE_BACKWARD_I
){
2281 s
->mv_dir
= MV_DIR_BACKWARD
;
2282 s
->mv_type
= MV_TYPE_FIELD
;
2285 j
= s
->field_select
[1][i
] = s
->b_field_select_table
[1][i
][xy
];
2286 s
->mv
[1][i
][0] = s
->b_field_mv_table
[1][i
][j
][xy
][0];
2287 s
->mv
[1][i
][1] = s
->b_field_mv_table
[1][i
][j
][xy
][1];
2289 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BACKWARD_I
, pb
, pb2
, tex_pb
,
2290 &dmin
, &next_block
, 0, 0);
2292 if(mb_type
&CANDIDATE_MB_TYPE_BIDIR_I
){
2293 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2294 s
->mv_type
= MV_TYPE_FIELD
;
2296 for(dir
=0; dir
<2; dir
++){
2298 j
= s
->field_select
[dir
][i
] = s
->b_field_select_table
[dir
][i
][xy
];
2299 s
->mv
[dir
][i
][0] = s
->b_field_mv_table
[dir
][i
][j
][xy
][0];
2300 s
->mv
[dir
][i
][1] = s
->b_field_mv_table
[dir
][i
][j
][xy
][1];
2303 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BIDIR_I
, pb
, pb2
, tex_pb
,
2304 &dmin
, &next_block
, 0, 0);
2306 if(mb_type
&CANDIDATE_MB_TYPE_INTRA
){
2308 s
->mv_type
= MV_TYPE_16X16
;
2312 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTRA
, pb
, pb2
, tex_pb
,
2313 &dmin
, &next_block
, 0, 0);
2314 if(s
->h263_pred
|| s
->h263_aic
){
2316 s
->mbintra_table
[mb_x
+ mb_y
*s
->mb_stride
]=1;
2318 ff_clean_intra_table_entries(s
); //old mode?
2322 if((s
->flags
& CODEC_FLAG_QP_RD
) && dmin
< INT_MAX
){
2323 if(best_s
.mv_type
==MV_TYPE_16X16
){ //FIXME move 4mv after QPRD
2324 const int last_qp
= backup_s
.qscale
;
2327 const int mvdir
= (best_s
.mv_dir
&MV_DIR_BACKWARD
) ? 1 : 0;
2328 static const int dquant_tab
[4]={-1,1,-2,2};
2330 assert(backup_s
.dquant
== 0);
2333 s
->mv_dir
= best_s
.mv_dir
;
2334 s
->mv_type
= MV_TYPE_16X16
;
2335 s
->mb_intra
= best_s
.mb_intra
;
2336 s
->mv
[0][0][0] = best_s
.mv
[0][0][0];
2337 s
->mv
[0][0][1] = best_s
.mv
[0][0][1];
2338 s
->mv
[1][0][0] = best_s
.mv
[1][0][0];
2339 s
->mv
[1][0][1] = best_s
.mv
[1][0][1];
2341 qpi
= s
->pict_type
== FF_B_TYPE
? 2 : 0;
2342 for(; qpi
<4; qpi
++){
2343 int dquant
= dquant_tab
[qpi
];
2344 qp
= last_qp
+ dquant
;
2345 if(qp
< s
->avctx
->qmin
|| qp
> s
->avctx
->qmax
)
2347 backup_s
.dquant
= dquant
;
2348 if(s
->mb_intra
&& s
->dc_val
[0]){
2350 dc
[i
]= s
->dc_val
[0][ s
->block_index
[i
] ];
2351 memcpy(ac
[i
], s
->ac_val
[0][s
->block_index
[i
]], sizeof(DCTELEM
)*16);
2355 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER
/* wrong but unused */, pb
, pb2
, tex_pb
,
2356 &dmin
, &next_block
, s
->mv
[mvdir
][0][0], s
->mv
[mvdir
][0][1]);
2357 if(best_s
.qscale
!= qp
){
2358 if(s
->mb_intra
&& s
->dc_val
[0]){
2360 s
->dc_val
[0][ s
->block_index
[i
] ]= dc
[i
];
2361 memcpy(s
->ac_val
[0][s
->block_index
[i
]], ac
[i
], sizeof(DCTELEM
)*16);
2368 if(CONFIG_MPEG4_ENCODER
&& mb_type
&CANDIDATE_MB_TYPE_DIRECT
){
2369 int mx
= s
->b_direct_mv_table
[xy
][0];
2370 int my
= s
->b_direct_mv_table
[xy
][1];
2372 backup_s
.dquant
= 0;
2373 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
| MV_DIRECT
;
2375 ff_mpeg4_set_direct_mv(s
, mx
, my
);
2376 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_DIRECT
, pb
, pb2
, tex_pb
,
2377 &dmin
, &next_block
, mx
, my
);
2379 if(CONFIG_MPEG4_ENCODER
&& mb_type
&CANDIDATE_MB_TYPE_DIRECT0
){
2380 backup_s
.dquant
= 0;
2381 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
| MV_DIRECT
;
2383 ff_mpeg4_set_direct_mv(s
, 0, 0);
2384 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_DIRECT
, pb
, pb2
, tex_pb
,
2385 &dmin
, &next_block
, 0, 0);
2387 if(!best_s
.mb_intra
&& s
->flags2
&CODEC_FLAG2_SKIP_RD
){
2390 coded
|= s
->block_last_index
[i
];
2393 memcpy(s
->mv
, best_s
.mv
, sizeof(s
->mv
));
2394 if(CONFIG_MPEG4_ENCODER
&& best_s
.mv_dir
& MV_DIRECT
){
2395 mx
=my
=0; //FIXME find the one we actually used
2396 ff_mpeg4_set_direct_mv(s
, mx
, my
);
2397 }else if(best_s
.mv_dir
&MV_DIR_BACKWARD
){
2405 s
->mv_dir
= best_s
.mv_dir
;
2406 s
->mv_type
= best_s
.mv_type
;
2408 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2409 s->mv[0][0][1] = best_s.mv[0][0][1];
2410 s->mv[1][0][0] = best_s.mv[1][0][0];
2411 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2414 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER
/* wrong but unused */, pb
, pb2
, tex_pb
,
2415 &dmin
, &next_block
, mx
, my
);
2420 s
->current_picture
.qscale_table
[xy
]= best_s
.qscale
;
2422 copy_context_after_encode(s
, &best_s
, -1);
2424 pb_bits_count
= put_bits_count(&s
->pb
);
2425 flush_put_bits(&s
->pb
);
2426 ff_copy_bits(&backup_s
.pb
, bit_buf
[next_block
^1], pb_bits_count
);
2429 if(s
->data_partitioning
){
2430 pb2_bits_count
= put_bits_count(&s
->pb2
);
2431 flush_put_bits(&s
->pb2
);
2432 ff_copy_bits(&backup_s
.pb2
, bit_buf2
[next_block
^1], pb2_bits_count
);
2433 s
->pb2
= backup_s
.pb2
;
2435 tex_pb_bits_count
= put_bits_count(&s
->tex_pb
);
2436 flush_put_bits(&s
->tex_pb
);
2437 ff_copy_bits(&backup_s
.tex_pb
, bit_buf_tex
[next_block
^1], tex_pb_bits_count
);
2438 s
->tex_pb
= backup_s
.tex_pb
;
2440 s
->last_bits
= put_bits_count(&s
->pb
);
2442 if (CONFIG_ANY_H263_ENCODER
&&
2443 s
->out_format
== FMT_H263
&& s
->pict_type
!=FF_B_TYPE
)
2444 ff_h263_update_motion_val(s
);
2446 if(next_block
==0){ //FIXME 16 vs linesize16
2447 s
->dsp
.put_pixels_tab
[0][0](s
->dest
[0], s
->rd_scratchpad
, s
->linesize
,16);
2448 s
->dsp
.put_pixels_tab
[1][0](s
->dest
[1], s
->rd_scratchpad
+ 16*s
->linesize
, s
->uvlinesize
, 8);
2449 s
->dsp
.put_pixels_tab
[1][0](s
->dest
[2], s
->rd_scratchpad
+ 16*s
->linesize
+ 8, s
->uvlinesize
, 8);
2452 if(s
->avctx
->mb_decision
== FF_MB_DECISION_BITS
)
2453 MPV_decode_mb(s
, s
->block
);
2455 int motion_x
= 0, motion_y
= 0;
2456 s
->mv_type
=MV_TYPE_16X16
;
2457 // only one MB-Type possible
2460 case CANDIDATE_MB_TYPE_INTRA
:
2463 motion_x
= s
->mv
[0][0][0] = 0;
2464 motion_y
= s
->mv
[0][0][1] = 0;
2466 case CANDIDATE_MB_TYPE_INTER
:
2467 s
->mv_dir
= MV_DIR_FORWARD
;
2469 motion_x
= s
->mv
[0][0][0] = s
->p_mv_table
[xy
][0];
2470 motion_y
= s
->mv
[0][0][1] = s
->p_mv_table
[xy
][1];
2472 case CANDIDATE_MB_TYPE_INTER_I
:
2473 s
->mv_dir
= MV_DIR_FORWARD
;
2474 s
->mv_type
= MV_TYPE_FIELD
;
2477 j
= s
->field_select
[0][i
] = s
->p_field_select_table
[i
][xy
];
2478 s
->mv
[0][i
][0] = s
->p_field_mv_table
[i
][j
][xy
][0];
2479 s
->mv
[0][i
][1] = s
->p_field_mv_table
[i
][j
][xy
][1];
2482 case CANDIDATE_MB_TYPE_INTER4V
:
2483 s
->mv_dir
= MV_DIR_FORWARD
;
2484 s
->mv_type
= MV_TYPE_8X8
;
2487 s
->mv
[0][i
][0] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][0];
2488 s
->mv
[0][i
][1] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][1];
2491 case CANDIDATE_MB_TYPE_DIRECT
:
2492 if (CONFIG_MPEG4_ENCODER
) {
2493 s
->mv_dir
= MV_DIR_FORWARD
|MV_DIR_BACKWARD
|MV_DIRECT
;
2495 motion_x
=s
->b_direct_mv_table
[xy
][0];
2496 motion_y
=s
->b_direct_mv_table
[xy
][1];
2497 ff_mpeg4_set_direct_mv(s
, motion_x
, motion_y
);
2500 case CANDIDATE_MB_TYPE_DIRECT0
:
2501 if (CONFIG_MPEG4_ENCODER
) {
2502 s
->mv_dir
= MV_DIR_FORWARD
|MV_DIR_BACKWARD
|MV_DIRECT
;
2504 ff_mpeg4_set_direct_mv(s
, 0, 0);
2507 case CANDIDATE_MB_TYPE_BIDIR
:
2508 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2510 s
->mv
[0][0][0] = s
->b_bidir_forw_mv_table
[xy
][0];
2511 s
->mv
[0][0][1] = s
->b_bidir_forw_mv_table
[xy
][1];
2512 s
->mv
[1][0][0] = s
->b_bidir_back_mv_table
[xy
][0];
2513 s
->mv
[1][0][1] = s
->b_bidir_back_mv_table
[xy
][1];
2515 case CANDIDATE_MB_TYPE_BACKWARD
:
2516 s
->mv_dir
= MV_DIR_BACKWARD
;
2518 motion_x
= s
->mv
[1][0][0] = s
->b_back_mv_table
[xy
][0];
2519 motion_y
= s
->mv
[1][0][1] = s
->b_back_mv_table
[xy
][1];
2521 case CANDIDATE_MB_TYPE_FORWARD
:
2522 s
->mv_dir
= MV_DIR_FORWARD
;
2524 motion_x
= s
->mv
[0][0][0] = s
->b_forw_mv_table
[xy
][0];
2525 motion_y
= s
->mv
[0][0][1] = s
->b_forw_mv_table
[xy
][1];
2526 // printf(" %d %d ", motion_x, motion_y);
2528 case CANDIDATE_MB_TYPE_FORWARD_I
:
2529 s
->mv_dir
= MV_DIR_FORWARD
;
2530 s
->mv_type
= MV_TYPE_FIELD
;
2533 j
= s
->field_select
[0][i
] = s
->b_field_select_table
[0][i
][xy
];
2534 s
->mv
[0][i
][0] = s
->b_field_mv_table
[0][i
][j
][xy
][0];
2535 s
->mv
[0][i
][1] = s
->b_field_mv_table
[0][i
][j
][xy
][1];
2538 case CANDIDATE_MB_TYPE_BACKWARD_I
:
2539 s
->mv_dir
= MV_DIR_BACKWARD
;
2540 s
->mv_type
= MV_TYPE_FIELD
;
2543 j
= s
->field_select
[1][i
] = s
->b_field_select_table
[1][i
][xy
];
2544 s
->mv
[1][i
][0] = s
->b_field_mv_table
[1][i
][j
][xy
][0];
2545 s
->mv
[1][i
][1] = s
->b_field_mv_table
[1][i
][j
][xy
][1];
2548 case CANDIDATE_MB_TYPE_BIDIR_I
:
2549 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2550 s
->mv_type
= MV_TYPE_FIELD
;
2552 for(dir
=0; dir
<2; dir
++){
2554 j
= s
->field_select
[dir
][i
] = s
->b_field_select_table
[dir
][i
][xy
];
2555 s
->mv
[dir
][i
][0] = s
->b_field_mv_table
[dir
][i
][j
][xy
][0];
2556 s
->mv
[dir
][i
][1] = s
->b_field_mv_table
[dir
][i
][j
][xy
][1];
2561 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal MB type\n");
2564 encode_mb(s
, motion_x
, motion_y
);
2566 // RAL: Update last macroblock type
2567 s
->last_mv_dir
= s
->mv_dir
;
2569 if (CONFIG_ANY_H263_ENCODER
&&
2570 s
->out_format
== FMT_H263
&& s
->pict_type
!=FF_B_TYPE
)
2571 ff_h263_update_motion_val(s
);
2573 MPV_decode_mb(s
, s
->block
);
2576 /* clean the MV table in IPS frames for direct mode in B frames */
2577 if(s
->mb_intra
/* && I,P,S_TYPE */){
2578 s
->p_mv_table
[xy
][0]=0;
2579 s
->p_mv_table
[xy
][1]=0;
2582 if(s
->flags
&CODEC_FLAG_PSNR
){
2586 if(s
->mb_x
*16 + 16 > s
->width
) w
= s
->width
- s
->mb_x
*16;
2587 if(s
->mb_y
*16 + 16 > s
->height
) h
= s
->height
- s
->mb_y
*16;
2589 s
->current_picture
.error
[0] += sse(
2590 s
, s
->new_picture
.data
[0] + s
->mb_x
*16 + s
->mb_y
*s
->linesize
*16,
2591 s
->dest
[0], w
, h
, s
->linesize
);
2592 s
->current_picture
.error
[1] += sse(
2593 s
, s
->new_picture
.data
[1] + s
->mb_x
*8 + s
->mb_y
*s
->uvlinesize
*chr_h
,
2594 s
->dest
[1], w
>>1, h
>>s
->chroma_y_shift
, s
->uvlinesize
);
2595 s
->current_picture
.error
[2] += sse(
2596 s
, s
->new_picture
.data
[2] + s
->mb_x
*8 + s
->mb_y
*s
->uvlinesize
*chr_h
,
2597 s
->dest
[2], w
>>1, h
>>s
->chroma_y_shift
, s
->uvlinesize
);
2600 if(CONFIG_ANY_H263_ENCODER
&& s
->out_format
== FMT_H263
)
2601 ff_h263_loop_filter(s
);
2603 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
2607 //not beautiful here but we must write it before flushing so it has to be here
2608 if (CONFIG_MSMPEG4_ENCODER
&& s
->msmpeg4_version
&& s
->msmpeg4_version
<4 && s
->pict_type
== FF_I_TYPE
)
2609 msmpeg4_encode_ext_header(s
);
2613 /* Send the last GOB if RTP */
2614 if (s
->avctx
->rtp_callback
) {
2615 int number_mb
= (mb_y
- s
->resync_mb_y
)*s
->mb_width
- s
->resync_mb_x
;
2616 pdif
= put_bits_ptr(&s
->pb
) - s
->ptr_lastgob
;
2617 /* Call the RTP callback to send the last GOB */
2619 s
->avctx
->rtp_callback(s
->avctx
, s
->ptr_lastgob
, pdif
, number_mb
);
2625 #define MERGE(field) dst->field += src->field; src->field=0
2626 static void merge_context_after_me(MpegEncContext
*dst
, MpegEncContext
*src
){
2627 MERGE(me
.scene_change_score
);
2628 MERGE(me
.mc_mb_var_sum_temp
);
2629 MERGE(me
.mb_var_sum_temp
);
2632 static void merge_context_after_encode(MpegEncContext
*dst
, MpegEncContext
*src
){
2635 MERGE(dct_count
[0]); //note, the other dct vars are not part of the context
2636 MERGE(dct_count
[1]);
2646 MERGE(padding_bug_score
);
2647 MERGE(current_picture
.error
[0]);
2648 MERGE(current_picture
.error
[1]);
2649 MERGE(current_picture
.error
[2]);
2651 if(dst
->avctx
->noise_reduction
){
2652 for(i
=0; i
<64; i
++){
2653 MERGE(dct_error_sum
[0][i
]);
2654 MERGE(dct_error_sum
[1][i
]);
2658 assert(put_bits_count(&src
->pb
) % 8 ==0);
2659 assert(put_bits_count(&dst
->pb
) % 8 ==0);
2660 ff_copy_bits(&dst
->pb
, src
->pb
.buf
, put_bits_count(&src
->pb
));
2661 flush_put_bits(&dst
->pb
);
2664 static int estimate_qp(MpegEncContext
*s
, int dry_run
){
2665 if (s
->next_lambda
){
2666 s
->current_picture_ptr
->quality
=
2667 s
->current_picture
.quality
= s
->next_lambda
;
2668 if(!dry_run
) s
->next_lambda
= 0;
2669 } else if (!s
->fixed_qscale
) {
2670 s
->current_picture_ptr
->quality
=
2671 s
->current_picture
.quality
= ff_rate_estimate_qscale(s
, dry_run
);
2672 if (s
->current_picture
.quality
< 0)
2676 if(s
->adaptive_quant
){
2677 switch(s
->codec_id
){
2678 case CODEC_ID_MPEG4
:
2679 if (CONFIG_MPEG4_ENCODER
)
2680 ff_clean_mpeg4_qscales(s
);
2683 case CODEC_ID_H263P
:
2685 if (CONFIG_H263_ENCODER
)
2686 ff_clean_h263_qscales(s
);
2690 s
->lambda
= s
->lambda_table
[0];
2693 s
->lambda
= s
->current_picture
.quality
;
2694 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
2699 /* must be called before writing the header */
2700 static void set_frame_distances(MpegEncContext
* s
){
2701 assert(s
->current_picture_ptr
->pts
!= AV_NOPTS_VALUE
);
2702 s
->time
= s
->current_picture_ptr
->pts
*s
->avctx
->time_base
.num
;
2704 if(s
->pict_type
==FF_B_TYPE
){
2705 s
->pb_time
= s
->pp_time
- (s
->last_non_b_time
- s
->time
);
2706 assert(s
->pb_time
> 0 && s
->pb_time
< s
->pp_time
);
2708 s
->pp_time
= s
->time
- s
->last_non_b_time
;
2709 s
->last_non_b_time
= s
->time
;
2710 assert(s
->picture_number
==0 || s
->pp_time
> 0);
2714 static int encode_picture(MpegEncContext
*s
, int picture_number
)
2719 s
->picture_number
= picture_number
;
2721 /* Reset the average MB variance */
2722 s
->me
.mb_var_sum_temp
=
2723 s
->me
.mc_mb_var_sum_temp
= 0;
2725 /* we need to initialize some time vars before we can encode b-frames */
2726 // RAL: Condition added for MPEG1VIDEO
2727 if (s
->codec_id
== CODEC_ID_MPEG1VIDEO
|| s
->codec_id
== CODEC_ID_MPEG2VIDEO
|| (s
->h263_pred
&& !s
->h263_msmpeg4
))
2728 set_frame_distances(s
);
2729 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
== CODEC_ID_MPEG4
)
2730 ff_set_mpeg4_time(s
);
2732 s
->me
.scene_change_score
=0;
2734 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
2736 if(s
->pict_type
==FF_I_TYPE
){
2737 if(s
->msmpeg4_version
>= 3) s
->no_rounding
=1;
2738 else s
->no_rounding
=0;
2739 }else if(s
->pict_type
!=FF_B_TYPE
){
2740 if(s
->flipflop_rounding
|| s
->codec_id
== CODEC_ID_H263P
|| s
->codec_id
== CODEC_ID_MPEG4
)
2741 s
->no_rounding
^= 1;
2744 if(s
->flags
& CODEC_FLAG_PASS2
){
2745 if (estimate_qp(s
,1) < 0)
2747 ff_get_2pass_fcode(s
);
2748 }else if(!(s
->flags
& CODEC_FLAG_QSCALE
)){
2749 if(s
->pict_type
==FF_B_TYPE
)
2750 s
->lambda
= s
->last_lambda_for
[s
->pict_type
];
2752 s
->lambda
= s
->last_lambda_for
[s
->last_non_b_pict_type
];
2756 s
->mb_intra
=0; //for the rate distortion & bit compare functions
2757 for(i
=1; i
<s
->avctx
->thread_count
; i
++){
2758 ff_update_duplicate_context(s
->thread_context
[i
], s
);
2764 /* Estimate motion for every MB */
2765 if(s
->pict_type
!= FF_I_TYPE
){
2766 s
->lambda
= (s
->lambda
* s
->avctx
->me_penalty_compensation
+ 128)>>8;
2767 s
->lambda2
= (s
->lambda2
* (int64_t)s
->avctx
->me_penalty_compensation
+ 128)>>8;
2768 if(s
->pict_type
!= FF_B_TYPE
&& s
->avctx
->me_threshold
==0){
2769 if((s
->avctx
->pre_me
&& s
->last_non_b_pict_type
==FF_I_TYPE
) || s
->avctx
->pre_me
==2){
2770 s
->avctx
->execute(s
->avctx
, pre_estimate_motion_thread
, (void**)&(s
->thread_context
[0]), NULL
, s
->avctx
->thread_count
, sizeof(void*));
2774 s
->avctx
->execute(s
->avctx
, estimate_motion_thread
, (void**)&(s
->thread_context
[0]), NULL
, s
->avctx
->thread_count
, sizeof(void*));
2775 }else /* if(s->pict_type == FF_I_TYPE) */{
2777 for(i
=0; i
<s
->mb_stride
*s
->mb_height
; i
++)
2778 s
->mb_type
[i
]= CANDIDATE_MB_TYPE_INTRA
;
2780 if(!s
->fixed_qscale
){
2781 /* finding spatial complexity for I-frame rate control */
2782 s
->avctx
->execute(s
->avctx
, mb_var_thread
, (void**)&(s
->thread_context
[0]), NULL
, s
->avctx
->thread_count
, sizeof(void*));
2785 for(i
=1; i
<s
->avctx
->thread_count
; i
++){
2786 merge_context_after_me(s
, s
->thread_context
[i
]);
2788 s
->current_picture
.mc_mb_var_sum
= s
->current_picture_ptr
->mc_mb_var_sum
= s
->me
.mc_mb_var_sum_temp
;
2789 s
->current_picture
. mb_var_sum
= s
->current_picture_ptr
-> mb_var_sum
= s
->me
. mb_var_sum_temp
;
2792 if(s
->me
.scene_change_score
> s
->avctx
->scenechange_threshold
&& s
->pict_type
== FF_P_TYPE
){
2793 s
->pict_type
= FF_I_TYPE
;
2794 for(i
=0; i
<s
->mb_stride
*s
->mb_height
; i
++)
2795 s
->mb_type
[i
]= CANDIDATE_MB_TYPE_INTRA
;
2796 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2800 if(s
->pict_type
==FF_P_TYPE
|| s
->pict_type
==FF_S_TYPE
) {
2801 s
->f_code
= ff_get_best_fcode(s
, s
->p_mv_table
, CANDIDATE_MB_TYPE_INTER
);
2803 if(s
->flags
& CODEC_FLAG_INTERLACED_ME
){
2805 a
= ff_get_best_fcode(s
, s
->p_field_mv_table
[0][0], CANDIDATE_MB_TYPE_INTER_I
); //FIXME field_select
2806 b
= ff_get_best_fcode(s
, s
->p_field_mv_table
[1][1], CANDIDATE_MB_TYPE_INTER_I
);
2807 s
->f_code
= FFMAX3(s
->f_code
, a
, b
);
2810 ff_fix_long_p_mvs(s
);
2811 ff_fix_long_mvs(s
, NULL
, 0, s
->p_mv_table
, s
->f_code
, CANDIDATE_MB_TYPE_INTER
, 0);
2812 if(s
->flags
& CODEC_FLAG_INTERLACED_ME
){
2816 ff_fix_long_mvs(s
, s
->p_field_select_table
[i
], j
,
2817 s
->p_field_mv_table
[i
][j
], s
->f_code
, CANDIDATE_MB_TYPE_INTER_I
, 0);
2822 if(s
->pict_type
==FF_B_TYPE
){
2825 a
= ff_get_best_fcode(s
, s
->b_forw_mv_table
, CANDIDATE_MB_TYPE_FORWARD
);
2826 b
= ff_get_best_fcode(s
, s
->b_bidir_forw_mv_table
, CANDIDATE_MB_TYPE_BIDIR
);
2827 s
->f_code
= FFMAX(a
, b
);
2829 a
= ff_get_best_fcode(s
, s
->b_back_mv_table
, CANDIDATE_MB_TYPE_BACKWARD
);
2830 b
= ff_get_best_fcode(s
, s
->b_bidir_back_mv_table
, CANDIDATE_MB_TYPE_BIDIR
);
2831 s
->b_code
= FFMAX(a
, b
);
2833 ff_fix_long_mvs(s
, NULL
, 0, s
->b_forw_mv_table
, s
->f_code
, CANDIDATE_MB_TYPE_FORWARD
, 1);
2834 ff_fix_long_mvs(s
, NULL
, 0, s
->b_back_mv_table
, s
->b_code
, CANDIDATE_MB_TYPE_BACKWARD
, 1);
2835 ff_fix_long_mvs(s
, NULL
, 0, s
->b_bidir_forw_mv_table
, s
->f_code
, CANDIDATE_MB_TYPE_BIDIR
, 1);
2836 ff_fix_long_mvs(s
, NULL
, 0, s
->b_bidir_back_mv_table
, s
->b_code
, CANDIDATE_MB_TYPE_BIDIR
, 1);
2837 if(s
->flags
& CODEC_FLAG_INTERLACED_ME
){
2839 for(dir
=0; dir
<2; dir
++){
2842 int type
= dir
? (CANDIDATE_MB_TYPE_BACKWARD_I
|CANDIDATE_MB_TYPE_BIDIR_I
)
2843 : (CANDIDATE_MB_TYPE_FORWARD_I
|CANDIDATE_MB_TYPE_BIDIR_I
);
2844 ff_fix_long_mvs(s
, s
->b_field_select_table
[dir
][i
], j
,
2845 s
->b_field_mv_table
[dir
][i
][j
], dir
? s
->b_code
: s
->f_code
, type
, 1);
2853 if (estimate_qp(s
, 0) < 0)
2856 if(s
->qscale
< 3 && s
->max_qcoeff
<=128 && s
->pict_type
==FF_I_TYPE
&& !(s
->flags
& CODEC_FLAG_QSCALE
))
2857 s
->qscale
= 3; //reduce clipping problems
2859 if (s
->out_format
== FMT_MJPEG
) {
2860 /* for mjpeg, we do include qscale in the matrix */
2861 s
->intra_matrix
[0] = ff_mpeg1_default_intra_matrix
[0];
2863 int j
= s
->dsp
.idct_permutation
[i
];
2865 s
->intra_matrix
[j
] = av_clip_uint8((ff_mpeg1_default_intra_matrix
[i
] * s
->qscale
) >> 3);
2867 ff_convert_matrix(&s
->dsp
, s
->q_intra_matrix
, s
->q_intra_matrix16
,
2868 s
->intra_matrix
, s
->intra_quant_bias
, 8, 8, 1);
2872 //FIXME var duplication
2873 s
->current_picture_ptr
->key_frame
=
2874 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
; //FIXME pic_ptr
2875 s
->current_picture_ptr
->pict_type
=
2876 s
->current_picture
.pict_type
= s
->pict_type
;
2878 if(s
->current_picture
.key_frame
)
2879 s
->picture_in_gop_number
=0;
2881 s
->last_bits
= put_bits_count(&s
->pb
);
2882 switch(s
->out_format
) {
2884 if (CONFIG_MJPEG_ENCODER
)
2885 ff_mjpeg_encode_picture_header(s
);
2888 if (CONFIG_H261_ENCODER
)
2889 ff_h261_encode_picture_header(s
, picture_number
);
2892 if (CONFIG_WMV2_ENCODER
&& s
->codec_id
== CODEC_ID_WMV2
)
2893 ff_wmv2_encode_picture_header(s
, picture_number
);
2894 else if (CONFIG_MSMPEG4_ENCODER
&& s
->h263_msmpeg4
)
2895 msmpeg4_encode_picture_header(s
, picture_number
);
2896 else if (CONFIG_MPEG4_ENCODER
&& s
->h263_pred
)
2897 mpeg4_encode_picture_header(s
, picture_number
);
2898 else if (CONFIG_RV10_ENCODER
&& s
->codec_id
== CODEC_ID_RV10
)
2899 rv10_encode_picture_header(s
, picture_number
);
2900 else if (CONFIG_RV20_ENCODER
&& s
->codec_id
== CODEC_ID_RV20
)
2901 rv20_encode_picture_header(s
, picture_number
);
2902 else if (CONFIG_FLV_ENCODER
&& s
->codec_id
== CODEC_ID_FLV1
)
2903 ff_flv_encode_picture_header(s
, picture_number
);
2904 else if (CONFIG_ANY_H263_ENCODER
)
2905 h263_encode_picture_header(s
, picture_number
);
2908 if (CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
)
2909 mpeg1_encode_picture_header(s
, picture_number
);
2916 bits
= put_bits_count(&s
->pb
);
2917 s
->header_bits
= bits
- s
->last_bits
;
2919 for(i
=1; i
<s
->avctx
->thread_count
; i
++){
2920 update_duplicate_context_after_me(s
->thread_context
[i
], s
);
2922 s
->avctx
->execute(s
->avctx
, encode_thread
, (void**)&(s
->thread_context
[0]), NULL
, s
->avctx
->thread_count
, sizeof(void*));
2923 for(i
=1; i
<s
->avctx
->thread_count
; i
++){
2924 merge_context_after_encode(s
, s
->thread_context
[i
]);
2930 void denoise_dct_c(MpegEncContext
*s
, DCTELEM
*block
){
2931 const int intra
= s
->mb_intra
;
2934 s
->dct_count
[intra
]++;
2936 for(i
=0; i
<64; i
++){
2937 int level
= block
[i
];
2941 s
->dct_error_sum
[intra
][i
] += level
;
2942 level
-= s
->dct_offset
[intra
][i
];
2943 if(level
<0) level
=0;
2945 s
->dct_error_sum
[intra
][i
] -= level
;
2946 level
+= s
->dct_offset
[intra
][i
];
2947 if(level
>0) level
=0;
2954 int dct_quantize_trellis_c(MpegEncContext
*s
,
2955 DCTELEM
*block
, int n
,
2956 int qscale
, int *overflow
){
2958 const uint8_t *scantable
= s
->intra_scantable
.scantable
;
2959 const uint8_t *perm_scantable
= s
->intra_scantable
.permutated
;
2961 unsigned int threshold1
, threshold2
;
2973 int coeff_count
[64];
2974 int qmul
, qadd
, start_i
, last_non_zero
, i
, dc
;
2975 const int esc_length
= s
->ac_esc_length
;
2977 uint8_t * last_length
;
2978 const int lambda
= s
->lambda2
>> (FF_LAMBDA_SHIFT
- 6);
2980 s
->dsp
.fdct (block
);
2982 if(s
->dct_error_sum
)
2983 s
->denoise_dct(s
, block
);
2985 qadd
= ((qscale
-1)|1)*8;
2996 /* For AIC we skip quant/dequant of INTRADC */
3001 /* note: block[0] is assumed to be positive */
3002 block
[0] = (block
[0] + (q
>> 1)) / q
;
3005 qmat
= s
->q_intra_matrix
[qscale
];
3006 if(s
->mpeg_quant
|| s
->out_format
== FMT_MPEG1
)
3007 bias
= 1<<(QMAT_SHIFT
-1);
3008 length
= s
->intra_ac_vlc_length
;
3009 last_length
= s
->intra_ac_vlc_last_length
;
3013 qmat
= s
->q_inter_matrix
[qscale
];
3014 length
= s
->inter_ac_vlc_length
;
3015 last_length
= s
->inter_ac_vlc_last_length
;
3019 threshold1
= (1<<QMAT_SHIFT
) - bias
- 1;
3020 threshold2
= (threshold1
<<1);
3022 for(i
=63; i
>=start_i
; i
--) {
3023 const int j
= scantable
[i
];
3024 int level
= block
[j
] * qmat
[j
];
3026 if(((unsigned)(level
+threshold1
))>threshold2
){
3032 for(i
=start_i
; i
<=last_non_zero
; i
++) {
3033 const int j
= scantable
[i
];
3034 int level
= block
[j
] * qmat
[j
];
3036 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3037 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3038 if(((unsigned)(level
+threshold1
))>threshold2
){
3040 level
= (bias
+ level
)>>QMAT_SHIFT
;
3042 coeff
[1][i
]= level
-1;
3043 // coeff[2][k]= level-2;
3045 level
= (bias
- level
)>>QMAT_SHIFT
;
3046 coeff
[0][i
]= -level
;
3047 coeff
[1][i
]= -level
+1;
3048 // coeff[2][k]= -level+2;
3050 coeff_count
[i
]= FFMIN(level
, 2);
3051 assert(coeff_count
[i
]);
3054 coeff
[0][i
]= (level
>>31)|1;
3059 *overflow
= s
->max_qcoeff
< max
; //overflow might have happened
3061 if(last_non_zero
< start_i
){
3062 memset(block
+ start_i
, 0, (64-start_i
)*sizeof(DCTELEM
));
3063 return last_non_zero
;
3066 score_tab
[start_i
]= 0;
3067 survivor
[0]= start_i
;
3070 for(i
=start_i
; i
<=last_non_zero
; i
++){
3071 int level_index
, j
, zero_distortion
;
3072 int dct_coeff
= FFABS(block
[ scantable
[i
] ]);
3073 int best_score
=256*256*256*120;
3075 if ( s
->dsp
.fdct
== fdct_ifast
3076 #ifndef FAAN_POSTSCALE
3077 || s
->dsp
.fdct
== ff_faandct
3080 dct_coeff
= (dct_coeff
*ff_inv_aanscales
[ scantable
[i
] ]) >> 12;
3081 zero_distortion
= dct_coeff
*dct_coeff
;
3083 for(level_index
=0; level_index
< coeff_count
[i
]; level_index
++){
3085 int level
= coeff
[level_index
][i
];
3086 const int alevel
= FFABS(level
);
3091 if(s
->out_format
== FMT_H263
){
3092 unquant_coeff
= alevel
*qmul
+ qadd
;
3094 j
= s
->dsp
.idct_permutation
[ scantable
[i
] ]; //FIXME optimize
3096 unquant_coeff
= (int)( alevel
* qscale
* s
->intra_matrix
[j
]) >> 3;
3097 unquant_coeff
= (unquant_coeff
- 1) | 1;
3099 unquant_coeff
= ((( alevel
<< 1) + 1) * qscale
* ((int) s
->inter_matrix
[j
])) >> 4;
3100 unquant_coeff
= (unquant_coeff
- 1) | 1;
3105 distortion
= (unquant_coeff
- dct_coeff
) * (unquant_coeff
- dct_coeff
) - zero_distortion
;
3107 if((level
&(~127)) == 0){
3108 for(j
=survivor_count
-1; j
>=0; j
--){
3109 int run
= i
- survivor
[j
];
3110 int score
= distortion
+ length
[UNI_AC_ENC_INDEX(run
, level
)]*lambda
;
3111 score
+= score_tab
[i
-run
];
3113 if(score
< best_score
){
3116 level_tab
[i
+1]= level
-64;
3120 if(s
->out_format
== FMT_H263
){
3121 for(j
=survivor_count
-1; j
>=0; j
--){
3122 int run
= i
- survivor
[j
];
3123 int score
= distortion
+ last_length
[UNI_AC_ENC_INDEX(run
, level
)]*lambda
;
3124 score
+= score_tab
[i
-run
];
3125 if(score
< last_score
){
3128 last_level
= level
-64;
3134 distortion
+= esc_length
*lambda
;
3135 for(j
=survivor_count
-1; j
>=0; j
--){
3136 int run
= i
- survivor
[j
];
3137 int score
= distortion
+ score_tab
[i
-run
];
3139 if(score
< best_score
){
3142 level_tab
[i
+1]= level
-64;
3146 if(s
->out_format
== FMT_H263
){
3147 for(j
=survivor_count
-1; j
>=0; j
--){
3148 int run
= i
- survivor
[j
];
3149 int score
= distortion
+ score_tab
[i
-run
];
3150 if(score
< last_score
){
3153 last_level
= level
-64;
3161 score_tab
[i
+1]= best_score
;
3163 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3164 if(last_non_zero
<= 27){
3165 for(; survivor_count
; survivor_count
--){
3166 if(score_tab
[ survivor
[survivor_count
-1] ] <= best_score
)
3170 for(; survivor_count
; survivor_count
--){
3171 if(score_tab
[ survivor
[survivor_count
-1] ] <= best_score
+ lambda
)
3176 survivor
[ survivor_count
++ ]= i
+1;
3179 if(s
->out_format
!= FMT_H263
){
3180 last_score
= 256*256*256*120;
3181 for(i
= survivor
[0]; i
<=last_non_zero
+ 1; i
++){
3182 int score
= score_tab
[i
];
3183 if(i
) score
+= lambda
*2; //FIXME exacter?
3185 if(score
< last_score
){
3188 last_level
= level_tab
[i
];
3189 last_run
= run_tab
[i
];
3194 s
->coded_score
[n
] = last_score
;
3196 dc
= FFABS(block
[0]);
3197 last_non_zero
= last_i
- 1;
3198 memset(block
+ start_i
, 0, (64-start_i
)*sizeof(DCTELEM
));
3200 if(last_non_zero
< start_i
)
3201 return last_non_zero
;
3203 if(last_non_zero
== 0 && start_i
== 0){
3205 int best_score
= dc
* dc
;
3207 for(i
=0; i
<coeff_count
[0]; i
++){
3208 int level
= coeff
[i
][0];
3209 int alevel
= FFABS(level
);
3210 int unquant_coeff
, score
, distortion
;
3212 if(s
->out_format
== FMT_H263
){
3213 unquant_coeff
= (alevel
*qmul
+ qadd
)>>3;
3215 unquant_coeff
= ((( alevel
<< 1) + 1) * qscale
* ((int) s
->inter_matrix
[0])) >> 4;
3216 unquant_coeff
= (unquant_coeff
- 1) | 1;
3218 unquant_coeff
= (unquant_coeff
+ 4) >> 3;
3219 unquant_coeff
<<= 3 + 3;
3221 distortion
= (unquant_coeff
- dc
) * (unquant_coeff
- dc
);
3223 if((level
&(~127)) == 0) score
= distortion
+ last_length
[UNI_AC_ENC_INDEX(0, level
)]*lambda
;
3224 else score
= distortion
+ esc_length
*lambda
;
3226 if(score
< best_score
){
3228 best_level
= level
- 64;
3231 block
[0]= best_level
;
3232 s
->coded_score
[n
] = best_score
- dc
*dc
;
3233 if(best_level
== 0) return -1;
3234 else return last_non_zero
;
3240 block
[ perm_scantable
[last_non_zero
] ]= last_level
;
3243 for(; i
>start_i
; i
-= run_tab
[i
] + 1){
3244 block
[ perm_scantable
[i
-1] ]= level_tab
[i
];
3247 return last_non_zero
;
3250 //#define REFINE_STATS 1
3251 static int16_t basis
[64][64];
3253 static void build_basis(uint8_t *perm
){
3260 double s
= 0.25*(1<<BASIS_SHIFT
);
3262 int perm_index
= perm
[index
];
3263 if(i
==0) s
*= sqrt(0.5);
3264 if(j
==0) s
*= sqrt(0.5);
3265 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)));
3272 static int dct_quantize_refine(MpegEncContext
*s
, //FIXME breaks denoise?
3273 DCTELEM
*block
, int16_t *weight
, DCTELEM
*orig
,
3276 DECLARE_ALIGNED_16(DCTELEM
, d1
[64]);
3277 const uint8_t *scantable
= s
->intra_scantable
.scantable
;
3278 const uint8_t *perm_scantable
= s
->intra_scantable
.permutated
;
3279 // unsigned int threshold1, threshold2;
3284 int qmul
, qadd
, start_i
, last_non_zero
, i
, dc
;
3286 uint8_t * last_length
;
3288 int rle_index
, run
, q
= 1, sum
; //q is only used when s->mb_intra is true
3291 static int after_last
=0;
3292 static int to_zero
=0;
3293 static int from_zero
=0;
3296 static int messed_sign
=0;
3299 if(basis
[0][0] == 0)
3300 build_basis(s
->dsp
.idct_permutation
);
3311 /* For AIC we skip quant/dequant of INTRADC */
3315 q
<<= RECON_SHIFT
-3;
3316 /* note: block[0] is assumed to be positive */
3318 // block[0] = (block[0] + (q >> 1)) / q;
3320 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3321 // bias= 1<<(QMAT_SHIFT-1);
3322 length
= s
->intra_ac_vlc_length
;
3323 last_length
= s
->intra_ac_vlc_last_length
;
3327 length
= s
->inter_ac_vlc_length
;
3328 last_length
= s
->inter_ac_vlc_last_length
;
3330 last_non_zero
= s
->block_last_index
[n
];
3335 dc
+= (1<<(RECON_SHIFT
-1));
3336 for(i
=0; i
<64; i
++){
3337 rem
[i
]= dc
- (orig
[i
]<<RECON_SHIFT
); //FIXME use orig dirrectly instead of copying to rem[]
3340 STOP_TIMER("memset rem[]")}
3343 for(i
=0; i
<64; i
++){
3348 w
= FFABS(weight
[i
]) + qns
*one
;
3349 w
= 15 + (48*qns
*one
+ w
/2)/w
; // 16 .. 63
3352 // w=weight[i] = (63*qns + (w/2)) / w;
3358 lambda
= sum
*(uint64_t)s
->lambda2
>> (FF_LAMBDA_SHIFT
- 6 + 6 + 6 + 6);
3364 for(i
=start_i
; i
<=last_non_zero
; i
++){
3365 int j
= perm_scantable
[i
];
3366 const int level
= block
[j
];
3370 if(level
<0) coeff
= qmul
*level
- qadd
;
3371 else coeff
= qmul
*level
+ qadd
;
3372 run_tab
[rle_index
++]=run
;
3375 s
->dsp
.add_8x8basis(rem
, basis
[j
], coeff
);
3381 if(last_non_zero
>0){
3382 STOP_TIMER("init rem[]")
3389 int best_score
=s
->dsp
.try_8x8basis(rem
, weight
, basis
[0], 0);
3392 int run2
, best_unquant_change
=0, analyze_gradient
;
3396 analyze_gradient
= last_non_zero
> 2 || s
->avctx
->quantizer_noise_shaping
>= 3;
3398 if(analyze_gradient
){
3402 for(i
=0; i
<64; i
++){
3405 d1
[i
] = (rem
[i
]*w
*w
+ (1<<(RECON_SHIFT
+12-1)))>>(RECON_SHIFT
+12);
3408 STOP_TIMER("rem*w*w")}
3418 const int level
= block
[0];
3419 int change
, old_coeff
;
3421 assert(s
->mb_intra
);
3425 for(change
=-1; change
<=1; change
+=2){
3426 int new_level
= level
+ change
;
3427 int score
, new_coeff
;
3429 new_coeff
= q
*new_level
;
3430 if(new_coeff
>= 2048 || new_coeff
< 0)
3433 score
= s
->dsp
.try_8x8basis(rem
, weight
, basis
[0], new_coeff
- old_coeff
);
3434 if(score
<best_score
){
3437 best_change
= change
;
3438 best_unquant_change
= new_coeff
- old_coeff
;
3445 run2
= run_tab
[rle_index
++];
3449 for(i
=start_i
; i
<64; i
++){
3450 int j
= perm_scantable
[i
];
3451 const int level
= block
[j
];
3452 int change
, old_coeff
;
3454 if(s
->avctx
->quantizer_noise_shaping
< 3 && i
> last_non_zero
+ 1)
3458 if(level
<0) old_coeff
= qmul
*level
- qadd
;
3459 else old_coeff
= qmul
*level
+ qadd
;
3460 run2
= run_tab
[rle_index
++]; //FIXME ! maybe after last
3464 assert(run2
>=0 || i
>= last_non_zero
);
3467 for(change
=-1; change
<=1; change
+=2){
3468 int new_level
= level
+ change
;
3469 int score
, new_coeff
, unquant_change
;
3472 if(s
->avctx
->quantizer_noise_shaping
< 2 && FFABS(new_level
) > FFABS(level
))
3476 if(new_level
<0) new_coeff
= qmul
*new_level
- qadd
;
3477 else new_coeff
= qmul
*new_level
+ qadd
;
3478 if(new_coeff
>= 2048 || new_coeff
<= -2048)
3480 //FIXME check for overflow
3483 if(level
< 63 && level
> -63){
3484 if(i
< last_non_zero
)
3485 score
+= length
[UNI_AC_ENC_INDEX(run
, new_level
+64)]
3486 - length
[UNI_AC_ENC_INDEX(run
, level
+64)];
3488 score
+= last_length
[UNI_AC_ENC_INDEX(run
, new_level
+64)]
3489 - last_length
[UNI_AC_ENC_INDEX(run
, level
+64)];
3492 assert(FFABS(new_level
)==1);
3494 if(analyze_gradient
){
3495 int g
= d1
[ scantable
[i
] ];
3496 if(g
&& (g
^new_level
) >= 0)
3500 if(i
< last_non_zero
){
3501 int next_i
= i
+ run2
+ 1;
3502 int next_level
= block
[ perm_scantable
[next_i
] ] + 64;
3504 if(next_level
&(~127))
3507 if(next_i
< last_non_zero
)
3508 score
+= length
[UNI_AC_ENC_INDEX(run
, 65)]
3509 + length
[UNI_AC_ENC_INDEX(run2
, next_level
)]
3510 - length
[UNI_AC_ENC_INDEX(run
+ run2
+ 1, next_level
)];
3512 score
+= length
[UNI_AC_ENC_INDEX(run
, 65)]
3513 + last_length
[UNI_AC_ENC_INDEX(run2
, next_level
)]
3514 - last_length
[UNI_AC_ENC_INDEX(run
+ run2
+ 1, next_level
)];
3516 score
+= last_length
[UNI_AC_ENC_INDEX(run
, 65)];
3518 score
+= length
[UNI_AC_ENC_INDEX(prev_run
, prev_level
)]
3519 - last_length
[UNI_AC_ENC_INDEX(prev_run
, prev_level
)];
3525 assert(FFABS(level
)==1);
3527 if(i
< last_non_zero
){
3528 int next_i
= i
+ run2
+ 1;
3529 int next_level
= block
[ perm_scantable
[next_i
] ] + 64;
3531 if(next_level
&(~127))
3534 if(next_i
< last_non_zero
)
3535 score
+= length
[UNI_AC_ENC_INDEX(run
+ run2
+ 1, next_level
)]
3536 - length
[UNI_AC_ENC_INDEX(run2
, next_level
)]
3537 - length
[UNI_AC_ENC_INDEX(run
, 65)];
3539 score
+= last_length
[UNI_AC_ENC_INDEX(run
+ run2
+ 1, next_level
)]
3540 - last_length
[UNI_AC_ENC_INDEX(run2
, next_level
)]
3541 - length
[UNI_AC_ENC_INDEX(run
, 65)];
3543 score
+= -last_length
[UNI_AC_ENC_INDEX(run
, 65)];
3545 score
+= last_length
[UNI_AC_ENC_INDEX(prev_run
, prev_level
)]
3546 - length
[UNI_AC_ENC_INDEX(prev_run
, prev_level
)];
3553 unquant_change
= new_coeff
- old_coeff
;
3554 assert((score
< 100*lambda
&& score
> -100*lambda
) || lambda
==0);
3556 score
+= s
->dsp
.try_8x8basis(rem
, weight
, basis
[j
], unquant_change
);
3557 if(score
<best_score
){
3560 best_change
= change
;
3561 best_unquant_change
= unquant_change
;
3565 prev_level
= level
+ 64;
3566 if(prev_level
&(~127))
3575 STOP_TIMER("iterative step")}
3579 int j
= perm_scantable
[ best_coeff
];
3581 block
[j
] += best_change
;
3583 if(best_coeff
> last_non_zero
){
3584 last_non_zero
= best_coeff
;
3592 if(block
[j
] - best_change
){
3593 if(FFABS(block
[j
]) > FFABS(block
[j
] - best_change
)){
3605 for(; last_non_zero
>=start_i
; last_non_zero
--){
3606 if(block
[perm_scantable
[last_non_zero
]])
3612 if(256*256*256*64 % count
== 0){
3613 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
);
3618 for(i
=start_i
; i
<=last_non_zero
; i
++){
3619 int j
= perm_scantable
[i
];
3620 const int level
= block
[j
];
3623 run_tab
[rle_index
++]=run
;
3630 s
->dsp
.add_8x8basis(rem
, basis
[j
], best_unquant_change
);
3636 if(last_non_zero
>0){
3637 STOP_TIMER("iterative search")
3642 return last_non_zero
;
3645 int dct_quantize_c(MpegEncContext
*s
,
3646 DCTELEM
*block
, int n
,
3647 int qscale
, int *overflow
)
3649 int i
, j
, level
, last_non_zero
, q
, start_i
;
3651 const uint8_t *scantable
= s
->intra_scantable
.scantable
;
3654 unsigned int threshold1
, threshold2
;
3656 s
->dsp
.fdct (block
);
3658 if(s
->dct_error_sum
)
3659 s
->denoise_dct(s
, block
);
3669 /* For AIC we skip quant/dequant of INTRADC */
3672 /* note: block[0] is assumed to be positive */
3673 block
[0] = (block
[0] + (q
>> 1)) / q
;
3676 qmat
= s
->q_intra_matrix
[qscale
];
3677 bias
= s
->intra_quant_bias
<<(QMAT_SHIFT
- QUANT_BIAS_SHIFT
);
3681 qmat
= s
->q_inter_matrix
[qscale
];
3682 bias
= s
->inter_quant_bias
<<(QMAT_SHIFT
- QUANT_BIAS_SHIFT
);
3684 threshold1
= (1<<QMAT_SHIFT
) - bias
- 1;
3685 threshold2
= (threshold1
<<1);
3686 for(i
=63;i
>=start_i
;i
--) {
3688 level
= block
[j
] * qmat
[j
];
3690 if(((unsigned)(level
+threshold1
))>threshold2
){
3697 for(i
=start_i
; i
<=last_non_zero
; i
++) {
3699 level
= block
[j
] * qmat
[j
];
3701 // if( bias+level >= (1<<QMAT_SHIFT)
3702 // || bias-level >= (1<<QMAT_SHIFT)){
3703 if(((unsigned)(level
+threshold1
))>threshold2
){
3705 level
= (bias
+ level
)>>QMAT_SHIFT
;
3708 level
= (bias
- level
)>>QMAT_SHIFT
;
3716 *overflow
= s
->max_qcoeff
< max
; //overflow might have happened
3718 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3719 if (s
->dsp
.idct_permutation_type
!= FF_NO_IDCT_PERM
)
3720 ff_block_permute(block
, s
->dsp
.idct_permutation
, scantable
, last_non_zero
);
3722 return last_non_zero
;
3725 AVCodec h263_encoder
= {
3729 sizeof(MpegEncContext
),
3733 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3734 .long_name
= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
3737 AVCodec h263p_encoder
= {
3741 sizeof(MpegEncContext
),
3745 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3746 .long_name
= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
3749 AVCodec flv_encoder
= {
3753 sizeof(MpegEncContext
),
3757 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3758 .long_name
= NULL_IF_CONFIG_SMALL("Flash Video (FLV)"),
3761 AVCodec mpeg4_encoder
= {
3765 sizeof(MpegEncContext
),
3769 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3770 .capabilities
= CODEC_CAP_DELAY
,
3771 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
3774 AVCodec msmpeg4v1_encoder
= {
3778 sizeof(MpegEncContext
),
3782 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3783 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
3786 AVCodec msmpeg4v2_encoder
= {
3790 sizeof(MpegEncContext
),
3794 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3795 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
3798 AVCodec msmpeg4v3_encoder
= {
3802 sizeof(MpegEncContext
),
3806 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3807 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
3810 AVCodec wmv1_encoder
= {
3814 sizeof(MpegEncContext
),
3818 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_YUV420P
, PIX_FMT_NONE
},
3819 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),