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
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/intmath.h"
33 #include "mpegvideo.h"
34 #include "mpegvideo_common.h"
39 #include "aandcttab.h"
41 #include "mpeg4video.h"
48 static int encode_picture(MpegEncContext
*s
, int picture_number
);
49 static int dct_quantize_refine(MpegEncContext
*s
, DCTELEM
*block
, int16_t *weight
, DCTELEM
*orig
, int n
, int qscale
);
50 static int sse_mb(MpegEncContext
*s
);
51 static void denoise_dct_c(MpegEncContext
*s
, DCTELEM
*block
);
52 static int dct_quantize_trellis_c(MpegEncContext
*s
, DCTELEM
*block
, int n
, int qscale
, int *overflow
);
54 /* enable all paranoid tests for rounding, overflows, etc... */
59 static uint8_t default_mv_penalty
[MAX_FCODE
+1][MAX_MV
*2+1];
60 static uint8_t default_fcode_tab
[MAX_MV
*2+1];
62 void ff_convert_matrix(DSPContext
*dsp
, int (*qmat
)[64], uint16_t (*qmat16
)[2][64],
63 const uint16_t *quant_matrix
, int bias
, int qmin
, int qmax
, int intra
)
68 for(qscale
=qmin
; qscale
<=qmax
; qscale
++){
70 if (dsp
->fdct
== ff_jpeg_fdct_islow
72 || dsp
->fdct
== ff_faandct
76 const int j
= dsp
->idct_permutation
[i
];
77 /* 16 <= qscale * quant_matrix[i] <= 7905 */
78 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
79 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1 << 36) / 249205026 */
80 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */
82 qmat
[qscale
][i
] = (int)((UINT64_C(1) << QMAT_SHIFT
) /
83 (qscale
* quant_matrix
[j
]));
85 } else if (dsp
->fdct
== fdct_ifast
86 #ifndef FAAN_POSTSCALE
87 || dsp
->fdct
== ff_faandct
91 const int j
= dsp
->idct_permutation
[i
];
92 /* 16 <= qscale * quant_matrix[i] <= 7905 */
93 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
94 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
95 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */
97 qmat
[qscale
][i
] = (int)((UINT64_C(1) << (QMAT_SHIFT
+ 14)) /
98 (ff_aanscales
[i
] * qscale
* quant_matrix
[j
]));
102 const int j
= dsp
->idct_permutation
[i
];
103 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
104 So 16 <= qscale * quant_matrix[i] <= 7905
105 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
106 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
108 qmat
[qscale
][i
] = (int)((UINT64_C(1) << QMAT_SHIFT
) / (qscale
* quant_matrix
[j
]));
109 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
110 qmat16
[qscale
][0][i
] = (1 << QMAT_SHIFT_MMX
) / (qscale
* quant_matrix
[j
]);
112 if(qmat16
[qscale
][0][i
]==0 || qmat16
[qscale
][0][i
]==128*256) qmat16
[qscale
][0][i
]=128*256-1;
113 qmat16
[qscale
][1][i
]= ROUNDED_DIV(bias
<<(16-QUANT_BIAS_SHIFT
), qmat16
[qscale
][0][i
]);
117 for(i
=intra
; i
<64; i
++){
119 if (dsp
->fdct
== fdct_ifast
120 #ifndef FAAN_POSTSCALE
121 || dsp
->fdct
== ff_faandct
124 max
= (8191LL*ff_aanscales
[i
]) >> 14;
126 while(((max
* qmat
[qscale
][i
]) >> shift
) > INT_MAX
){
132 av_log(NULL
, AV_LOG_INFO
, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT
- shift
);
136 static inline void update_qscale(MpegEncContext
*s
){
137 s
->qscale
= (s
->lambda
*139 + FF_LAMBDA_SCALE
*64) >> (FF_LAMBDA_SHIFT
+ 7);
138 s
->qscale
= av_clip(s
->qscale
, s
->avctx
->qmin
, s
->avctx
->qmax
);
140 s
->lambda2
= (s
->lambda
*s
->lambda
+ FF_LAMBDA_SCALE
/2) >> FF_LAMBDA_SHIFT
;
143 void ff_write_quant_matrix(PutBitContext
*pb
, uint16_t *matrix
){
149 put_bits(pb
, 8, matrix
[ ff_zigzag_direct
[i
] ]);
156 * init s->current_picture.qscale_table from s->lambda_table
158 void ff_init_qscale_tab(MpegEncContext
*s
){
159 int8_t * const qscale_table
= s
->current_picture
.qscale_table
;
162 for(i
=0; i
<s
->mb_num
; i
++){
163 unsigned int lam
= s
->lambda_table
[ s
->mb_index2xy
[i
] ];
164 int qp
= (lam
*139 + FF_LAMBDA_SCALE
*64) >> (FF_LAMBDA_SHIFT
+ 7);
165 qscale_table
[ s
->mb_index2xy
[i
] ]= av_clip(qp
, s
->avctx
->qmin
, s
->avctx
->qmax
);
169 static void copy_picture_attributes(MpegEncContext
*s
, AVFrame
*dst
, AVFrame
*src
){
172 dst
->pict_type
= src
->pict_type
;
173 dst
->quality
= src
->quality
;
174 dst
->coded_picture_number
= src
->coded_picture_number
;
175 dst
->display_picture_number
= src
->display_picture_number
;
176 // dst->reference = src->reference;
178 dst
->interlaced_frame
= src
->interlaced_frame
;
179 dst
->top_field_first
= src
->top_field_first
;
181 if(s
->avctx
->me_threshold
){
182 if(!src
->motion_val
[0])
183 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.motion_val not set!\n");
185 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.mb_type not set!\n");
186 if(!src
->ref_index
[0])
187 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.ref_index not set!\n");
188 if(src
->motion_subsample_log2
!= dst
->motion_subsample_log2
)
189 av_log(s
->avctx
, AV_LOG_ERROR
, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
190 src
->motion_subsample_log2
, dst
->motion_subsample_log2
);
192 memcpy(dst
->mb_type
, src
->mb_type
, s
->mb_stride
* s
->mb_height
* sizeof(dst
->mb_type
[0]));
195 int stride
= ((16*s
->mb_width
)>>src
->motion_subsample_log2
) + 1;
196 int height
= ((16*s
->mb_height
)>>src
->motion_subsample_log2
);
198 if(src
->motion_val
[i
] && src
->motion_val
[i
] != dst
->motion_val
[i
]){
199 memcpy(dst
->motion_val
[i
], src
->motion_val
[i
], 2*stride
*height
*sizeof(int16_t));
201 if(src
->ref_index
[i
] && src
->ref_index
[i
] != dst
->ref_index
[i
]){
202 memcpy(dst
->ref_index
[i
], src
->ref_index
[i
], s
->mb_stride
*4*s
->mb_height
*sizeof(int8_t));
208 static void update_duplicate_context_after_me(MpegEncContext
*dst
, MpegEncContext
*src
){
209 #define COPY(a) dst->a= src->a
211 COPY(current_picture
);
217 COPY(picture_in_gop_number
);
218 COPY(gop_picture_number
);
219 COPY(frame_pred_frame_dct
); //FIXME don't set in encode_header
220 COPY(progressive_frame
); //FIXME don't set in encode_header
221 COPY(partitioned_frame
); //FIXME don't set in encode_header
226 * sets the given MpegEncContext to defaults for encoding.
227 * the changed fields will not depend upon the prior state of the MpegEncContext.
229 static void MPV_encode_defaults(MpegEncContext
*s
){
231 MPV_common_defaults(s
);
233 for(i
=-16; i
<16; i
++){
234 default_fcode_tab
[i
+ MAX_MV
]= 1;
236 s
->me
.mv_penalty
= default_mv_penalty
;
237 s
->fcode_tab
= default_fcode_tab
;
240 /* init video encoder */
241 av_cold
int MPV_encode_init(AVCodecContext
*avctx
)
243 MpegEncContext
*s
= avctx
->priv_data
;
245 int chroma_h_shift
, chroma_v_shift
;
247 MPV_encode_defaults(s
);
249 switch (avctx
->codec_id
) {
250 case CODEC_ID_MPEG2VIDEO
:
251 if(avctx
->pix_fmt
!= PIX_FMT_YUV420P
&& avctx
->pix_fmt
!= PIX_FMT_YUV422P
){
252 av_log(avctx
, AV_LOG_ERROR
, "only YUV420 and YUV422 are supported\n");
257 if(avctx
->pix_fmt
!= PIX_FMT_YUVJ420P
&& avctx
->pix_fmt
!= PIX_FMT_YUVJ422P
&& avctx
->pix_fmt
!= PIX_FMT_YUVJ444P
&& avctx
->pix_fmt
!= PIX_FMT_BGRA
&&
258 ((avctx
->pix_fmt
!= PIX_FMT_YUV420P
&& avctx
->pix_fmt
!= PIX_FMT_YUV422P
&& avctx
->pix_fmt
!= PIX_FMT_YUV444P
) || avctx
->strict_std_compliance
>FF_COMPLIANCE_UNOFFICIAL
)){
259 av_log(avctx
, AV_LOG_ERROR
, "colorspace not supported in LJPEG\n");
264 if(avctx
->pix_fmt
!= PIX_FMT_YUVJ420P
&& avctx
->pix_fmt
!= PIX_FMT_YUVJ422P
&&
265 ((avctx
->pix_fmt
!= PIX_FMT_YUV420P
&& avctx
->pix_fmt
!= PIX_FMT_YUV422P
) || avctx
->strict_std_compliance
>FF_COMPLIANCE_UNOFFICIAL
)){
266 av_log(avctx
, AV_LOG_ERROR
, "colorspace not supported in jpeg\n");
271 if(avctx
->pix_fmt
!= PIX_FMT_YUV420P
){
272 av_log(avctx
, AV_LOG_ERROR
, "only YUV420 is supported\n");
277 switch (avctx
->pix_fmt
) {
278 case PIX_FMT_YUVJ422P
:
279 case PIX_FMT_YUV422P
:
280 s
->chroma_format
= CHROMA_422
;
282 case PIX_FMT_YUVJ420P
:
283 case PIX_FMT_YUV420P
:
285 s
->chroma_format
= CHROMA_420
;
289 s
->bit_rate
= avctx
->bit_rate
;
290 s
->width
= avctx
->width
;
291 s
->height
= avctx
->height
;
292 if(avctx
->gop_size
> 600 && avctx
->strict_std_compliance
>FF_COMPLIANCE_EXPERIMENTAL
){
293 av_log(avctx
, AV_LOG_ERROR
, "Warning keyframe interval too large! reducing it ...\n");
296 s
->gop_size
= avctx
->gop_size
;
298 s
->flags
= avctx
->flags
;
299 s
->flags2
= avctx
->flags2
;
300 s
->max_b_frames
= avctx
->max_b_frames
;
301 s
->codec_id
= avctx
->codec
->id
;
302 s
->luma_elim_threshold
= avctx
->luma_elim_threshold
;
303 s
->chroma_elim_threshold
= avctx
->chroma_elim_threshold
;
304 s
->strict_std_compliance
= avctx
->strict_std_compliance
;
305 s
->data_partitioning
= avctx
->flags
& CODEC_FLAG_PART
;
306 s
->quarter_sample
= (avctx
->flags
& CODEC_FLAG_QPEL
)!=0;
307 s
->mpeg_quant
= avctx
->mpeg_quant
;
308 s
->rtp_mode
= !!avctx
->rtp_payload_size
;
309 s
->intra_dc_precision
= avctx
->intra_dc_precision
;
310 s
->user_specified_pts
= AV_NOPTS_VALUE
;
312 if (s
->gop_size
<= 1) {
319 s
->me_method
= avctx
->me_method
;
322 s
->fixed_qscale
= !!(avctx
->flags
& CODEC_FLAG_QSCALE
);
324 s
->adaptive_quant
= ( s
->avctx
->lumi_masking
325 || s
->avctx
->dark_masking
326 || s
->avctx
->temporal_cplx_masking
327 || s
->avctx
->spatial_cplx_masking
328 || s
->avctx
->p_masking
329 || s
->avctx
->border_masking
330 || (s
->flags
&CODEC_FLAG_QP_RD
))
333 s
->obmc
= !!(s
->flags
& CODEC_FLAG_OBMC
);
334 s
->loop_filter
= !!(s
->flags
& CODEC_FLAG_LOOP_FILTER
);
335 s
->alternate_scan
= !!(s
->flags
& CODEC_FLAG_ALT_SCAN
);
336 s
->intra_vlc_format
= !!(s
->flags2
& CODEC_FLAG2_INTRA_VLC
);
337 s
->q_scale_type
= !!(s
->flags2
& CODEC_FLAG2_NON_LINEAR_QUANT
);
339 if(avctx
->rc_max_rate
&& !avctx
->rc_buffer_size
){
340 av_log(avctx
, AV_LOG_ERROR
, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
344 if(avctx
->rc_min_rate
&& avctx
->rc_max_rate
!= avctx
->rc_min_rate
){
345 av_log(avctx
, AV_LOG_INFO
, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
348 if(avctx
->rc_min_rate
&& avctx
->rc_min_rate
> avctx
->bit_rate
){
349 av_log(avctx
, AV_LOG_ERROR
, "bitrate below min bitrate\n");
353 if(avctx
->rc_max_rate
&& avctx
->rc_max_rate
< avctx
->bit_rate
){
354 av_log(avctx
, AV_LOG_INFO
, "bitrate above max bitrate\n");
358 if(avctx
->rc_max_rate
&& avctx
->rc_max_rate
== avctx
->bit_rate
&& avctx
->rc_max_rate
!= avctx
->rc_min_rate
){
359 av_log(avctx
, AV_LOG_INFO
, "impossible bitrate constraints, this will fail\n");
362 if(avctx
->rc_buffer_size
&& avctx
->bit_rate
*(int64_t)avctx
->time_base
.num
> avctx
->rc_buffer_size
* (int64_t)avctx
->time_base
.den
){
363 av_log(avctx
, AV_LOG_ERROR
, "VBV buffer too small for bitrate\n");
367 if(!s
->fixed_qscale
&& avctx
->bit_rate
*av_q2d(avctx
->time_base
) > avctx
->bit_rate_tolerance
){
368 av_log(avctx
, AV_LOG_ERROR
, "bitrate tolerance too small for bitrate\n");
372 if( s
->avctx
->rc_max_rate
&& s
->avctx
->rc_min_rate
== s
->avctx
->rc_max_rate
373 && (s
->codec_id
== CODEC_ID_MPEG1VIDEO
|| s
->codec_id
== CODEC_ID_MPEG2VIDEO
)
374 && 90000LL * (avctx
->rc_buffer_size
-1) > s
->avctx
->rc_max_rate
*0xFFFFLL
){
376 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");
379 if((s
->flags
& CODEC_FLAG_4MV
) && s
->codec_id
!= CODEC_ID_MPEG4
380 && s
->codec_id
!= CODEC_ID_H263
&& s
->codec_id
!= CODEC_ID_H263P
&& s
->codec_id
!= CODEC_ID_FLV1
){
381 av_log(avctx
, AV_LOG_ERROR
, "4MV not supported by codec\n");
385 if(s
->obmc
&& s
->avctx
->mb_decision
!= FF_MB_DECISION_SIMPLE
){
386 av_log(avctx
, AV_LOG_ERROR
, "OBMC is only supported with simple mb decision\n");
390 if(s
->obmc
&& s
->codec_id
!= CODEC_ID_H263
&& s
->codec_id
!= CODEC_ID_H263P
){
391 av_log(avctx
, AV_LOG_ERROR
, "OBMC is only supported with H263(+)\n");
395 if(s
->quarter_sample
&& s
->codec_id
!= CODEC_ID_MPEG4
){
396 av_log(avctx
, AV_LOG_ERROR
, "qpel not supported by codec\n");
400 if(s
->data_partitioning
&& s
->codec_id
!= CODEC_ID_MPEG4
){
401 av_log(avctx
, AV_LOG_ERROR
, "data partitioning not supported by codec\n");
405 if(s
->max_b_frames
&& s
->codec_id
!= CODEC_ID_MPEG4
&& s
->codec_id
!= CODEC_ID_MPEG1VIDEO
&& s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
406 av_log(avctx
, AV_LOG_ERROR
, "b frames not supported by codec\n");
410 if ((s
->codec_id
== CODEC_ID_MPEG4
|| s
->codec_id
== CODEC_ID_H263
||
411 s
->codec_id
== CODEC_ID_H263P
) &&
412 (avctx
->sample_aspect_ratio
.num
> 255 || avctx
->sample_aspect_ratio
.den
> 255)) {
413 av_log(avctx
, AV_LOG_ERROR
, "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
414 avctx
->sample_aspect_ratio
.num
, avctx
->sample_aspect_ratio
.den
);
418 if((s
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
|CODEC_FLAG_ALT_SCAN
))
419 && s
->codec_id
!= CODEC_ID_MPEG4
&& s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
420 av_log(avctx
, AV_LOG_ERROR
, "interlacing not supported by codec\n");
424 if(s
->mpeg_quant
&& s
->codec_id
!= CODEC_ID_MPEG4
){ //FIXME mpeg2 uses that too
425 av_log(avctx
, AV_LOG_ERROR
, "mpeg2 style quantization not supported by codec\n");
429 if((s
->flags
& CODEC_FLAG_CBP_RD
) && !avctx
->trellis
){
430 av_log(avctx
, AV_LOG_ERROR
, "CBP RD needs trellis quant\n");
434 if((s
->flags
& CODEC_FLAG_QP_RD
) && s
->avctx
->mb_decision
!= FF_MB_DECISION_RD
){
435 av_log(avctx
, AV_LOG_ERROR
, "QP RD needs mbd=2\n");
439 if(s
->avctx
->scenechange_threshold
< 1000000000 && (s
->flags
& CODEC_FLAG_CLOSED_GOP
)){
440 av_log(avctx
, AV_LOG_ERROR
, "closed gop with scene change detection are not supported yet, set threshold to 1000000000\n");
444 if((s
->flags2
& CODEC_FLAG2_INTRA_VLC
) && s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
445 av_log(avctx
, AV_LOG_ERROR
, "intra vlc table not supported by codec\n");
449 if(s
->flags
& CODEC_FLAG_LOW_DELAY
){
450 if (s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
451 av_log(avctx
, AV_LOG_ERROR
, "low delay forcing is only available for mpeg2\n");
454 if (s
->max_b_frames
!= 0){
455 av_log(avctx
, AV_LOG_ERROR
, "b frames cannot be used with low delay\n");
460 if(s
->q_scale_type
== 1){
461 if(s
->codec_id
!= CODEC_ID_MPEG2VIDEO
){
462 av_log(avctx
, AV_LOG_ERROR
, "non linear quant is only available for mpeg2\n");
465 if(avctx
->qmax
> 12){
466 av_log(avctx
, AV_LOG_ERROR
, "non linear quant only supports qmax <= 12 currently\n");
471 if(s
->avctx
->thread_count
> 1 && s
->codec_id
!= CODEC_ID_MPEG4
472 && s
->codec_id
!= CODEC_ID_MPEG1VIDEO
&& s
->codec_id
!= CODEC_ID_MPEG2VIDEO
473 && (s
->codec_id
!= CODEC_ID_H263P
|| !(s
->flags
& CODEC_FLAG_H263P_SLICE_STRUCT
))){
474 av_log(avctx
, AV_LOG_ERROR
, "multi threaded encoding not supported by codec\n");
478 if(s
->avctx
->thread_count
< 1){
479 av_log(avctx
, AV_LOG_ERROR
, "automatic thread number detection not supported by codec, patch welcome\n");
483 if(s
->avctx
->thread_count
> 1)
486 if(!avctx
->time_base
.den
|| !avctx
->time_base
.num
){
487 av_log(avctx
, AV_LOG_ERROR
, "framerate not set\n");
491 i
= (INT_MAX
/2+128)>>8;
492 if(avctx
->me_threshold
>= i
){
493 av_log(avctx
, AV_LOG_ERROR
, "me_threshold too large, max is %d\n", i
- 1);
496 if(avctx
->mb_threshold
>= i
){
497 av_log(avctx
, AV_LOG_ERROR
, "mb_threshold too large, max is %d\n", i
- 1);
501 if(avctx
->b_frame_strategy
&& (avctx
->flags
&CODEC_FLAG_PASS2
)){
502 av_log(avctx
, AV_LOG_INFO
, "notice: b_frame_strategy only affects the first pass\n");
503 avctx
->b_frame_strategy
= 0;
506 i
= av_gcd(avctx
->time_base
.den
, avctx
->time_base
.num
);
508 av_log(avctx
, AV_LOG_INFO
, "removing common factors from framerate\n");
509 avctx
->time_base
.den
/= i
;
510 avctx
->time_base
.num
/= i
;
514 if(s
->mpeg_quant
|| s
->codec_id
==CODEC_ID_MPEG1VIDEO
|| s
->codec_id
==CODEC_ID_MPEG2VIDEO
|| s
->codec_id
==CODEC_ID_MJPEG
){
515 s
->intra_quant_bias
= 3<<(QUANT_BIAS_SHIFT
-3); //(a + x*3/8)/x
516 s
->inter_quant_bias
= 0;
518 s
->intra_quant_bias
=0;
519 s
->inter_quant_bias
=-(1<<(QUANT_BIAS_SHIFT
-2)); //(a - x/4)/x
522 if(avctx
->intra_quant_bias
!= FF_DEFAULT_QUANT_BIAS
)
523 s
->intra_quant_bias
= avctx
->intra_quant_bias
;
524 if(avctx
->inter_quant_bias
!= FF_DEFAULT_QUANT_BIAS
)
525 s
->inter_quant_bias
= avctx
->inter_quant_bias
;
527 avcodec_get_chroma_sub_sample(avctx
->pix_fmt
, &chroma_h_shift
, &chroma_v_shift
);
529 if(avctx
->codec_id
== CODEC_ID_MPEG4
&& s
->avctx
->time_base
.den
> (1<<16)-1){
530 av_log(avctx
, AV_LOG_ERROR
, "timebase %d/%d not supported by MPEG 4 standard, "
531 "the maximum admitted value for the timebase denominator is %d\n",
532 s
->avctx
->time_base
.num
, s
->avctx
->time_base
.den
, (1<<16)-1);
535 s
->time_increment_bits
= av_log2(s
->avctx
->time_base
.den
- 1) + 1;
537 switch(avctx
->codec
->id
) {
538 case CODEC_ID_MPEG1VIDEO
:
539 s
->out_format
= FMT_MPEG1
;
540 s
->low_delay
= !!(s
->flags
& CODEC_FLAG_LOW_DELAY
);
541 avctx
->delay
= s
->low_delay ?
0 : (s
->max_b_frames
+ 1);
543 case CODEC_ID_MPEG2VIDEO
:
544 s
->out_format
= FMT_MPEG1
;
545 s
->low_delay
= !!(s
->flags
& CODEC_FLAG_LOW_DELAY
);
546 avctx
->delay
= s
->low_delay ?
0 : (s
->max_b_frames
+ 1);
551 s
->out_format
= FMT_MJPEG
;
552 s
->intra_only
= 1; /* force intra only for jpeg */
553 if(avctx
->codec
->id
== CODEC_ID_LJPEG
&& avctx
->pix_fmt
== PIX_FMT_BGRA
){
554 s
->mjpeg_vsample
[0] = s
->mjpeg_hsample
[0] =
555 s
->mjpeg_vsample
[1] = s
->mjpeg_hsample
[1] =
556 s
->mjpeg_vsample
[2] = s
->mjpeg_hsample
[2] = 1;
558 s
->mjpeg_vsample
[0] = 2;
559 s
->mjpeg_vsample
[1] = 2>>chroma_v_shift
;
560 s
->mjpeg_vsample
[2] = 2>>chroma_v_shift
;
561 s
->mjpeg_hsample
[0] = 2;
562 s
->mjpeg_hsample
[1] = 2>>chroma_h_shift
;
563 s
->mjpeg_hsample
[2] = 2>>chroma_h_shift
;
565 if (!(CONFIG_MJPEG_ENCODER
|| CONFIG_LJPEG_ENCODER
)
566 || ff_mjpeg_encode_init(s
) < 0)
572 if (!CONFIG_H261_ENCODER
) return -1;
573 if (ff_h261_get_picture_format(s
->width
, s
->height
) < 0) {
574 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
);
577 s
->out_format
= FMT_H261
;
582 if (!CONFIG_H263_ENCODER
) return -1;
583 if (ff_match_2uint16(h263_format
, FF_ARRAY_ELEMS(h263_format
), s
->width
, s
->height
) == 8) {
584 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
);
587 s
->out_format
= FMT_H263
;
588 s
->obmc
= (avctx
->flags
& CODEC_FLAG_OBMC
) ?
1:0;
593 s
->out_format
= FMT_H263
;
596 s
->umvplus
= (avctx
->flags
& CODEC_FLAG_H263P_UMV
) ?
1:0;
597 s
->h263_aic
= (avctx
->flags
& CODEC_FLAG_AC_PRED
) ?
1:0;
598 s
->modified_quant
= s
->h263_aic
;
599 s
->alt_inter_vlc
= (avctx
->flags
& CODEC_FLAG_H263P_AIV
) ?
1:0;
600 s
->obmc
= (avctx
->flags
& CODEC_FLAG_OBMC
) ?
1:0;
601 s
->loop_filter
= (avctx
->flags
& CODEC_FLAG_LOOP_FILTER
) ?
1:0;
602 s
->unrestricted_mv
= s
->obmc
|| s
->loop_filter
|| s
->umvplus
;
603 s
->h263_slice_structured
= (s
->flags
& CODEC_FLAG_H263P_SLICE_STRUCT
) ?
1:0;
606 /* These are just to be sure */
611 s
->out_format
= FMT_H263
;
612 s
->h263_flv
= 2; /* format = 1; 11-bit codes */
613 s
->unrestricted_mv
= 1;
614 s
->rtp_mode
=0; /* don't allow GOB */
619 s
->out_format
= FMT_H263
;
624 s
->out_format
= FMT_H263
;
631 s
->unrestricted_mv
= 0;
634 s
->out_format
= FMT_H263
;
636 s
->unrestricted_mv
= 1;
637 s
->low_delay
= s
->max_b_frames ?
0 : 1;
638 avctx
->delay
= s
->low_delay ?
0 : (s
->max_b_frames
+ 1);
640 case CODEC_ID_MSMPEG4V1
:
641 s
->out_format
= FMT_H263
;
644 s
->unrestricted_mv
= 1;
645 s
->msmpeg4_version
= 1;
649 case CODEC_ID_MSMPEG4V2
:
650 s
->out_format
= FMT_H263
;
653 s
->unrestricted_mv
= 1;
654 s
->msmpeg4_version
= 2;
658 case CODEC_ID_MSMPEG4V3
:
659 s
->out_format
= FMT_H263
;
662 s
->unrestricted_mv
= 1;
663 s
->msmpeg4_version
= 3;
664 s
->flipflop_rounding
=1;
669 s
->out_format
= FMT_H263
;
672 s
->unrestricted_mv
= 1;
673 s
->msmpeg4_version
= 4;
674 s
->flipflop_rounding
=1;
679 s
->out_format
= FMT_H263
;
682 s
->unrestricted_mv
= 1;
683 s
->msmpeg4_version
= 5;
684 s
->flipflop_rounding
=1;
692 avctx
->has_b_frames
= !s
->low_delay
;
696 s
->progressive_frame
=
697 s
->progressive_sequence
= !(avctx
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
|CODEC_FLAG_ALT_SCAN
));
700 if (MPV_common_init(s
) < 0)
704 s
->dct_quantize
= dct_quantize_c
;
706 s
->denoise_dct
= denoise_dct_c
;
707 s
->fast_dct_quantize
= s
->dct_quantize
;
709 s
->dct_quantize
= dct_quantize_trellis_c
;
711 if((CONFIG_H263P_ENCODER
|| CONFIG_RV20_ENCODER
) && s
->modified_quant
)
712 s
->chroma_qscale_table
= ff_h263_chroma_qscale_table
;
714 s
->quant_precision
=5;
716 ff_set_cmp(&s
->dsp
, s
->dsp
.ildct_cmp
, s
->avctx
->ildct_cmp
);
717 ff_set_cmp(&s
->dsp
, s
->dsp
.frame_skip_cmp
, s
->avctx
->frame_skip_cmp
);
719 if (CONFIG_H261_ENCODER
&& s
->out_format
== FMT_H261
)
720 ff_h261_encode_init(s
);
721 if (CONFIG_H263_ENCODER
&& s
->out_format
== FMT_H263
)
723 if (CONFIG_MSMPEG4_ENCODER
&& s
->msmpeg4_version
)
724 ff_msmpeg4_encode_init(s
);
725 if ((CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
)
726 && s
->out_format
== FMT_MPEG1
)
727 ff_mpeg1_encode_init(s
);
731 int j
= s
->dsp
.idct_permutation
[i
];
732 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
==CODEC_ID_MPEG4
&& s
->mpeg_quant
){
733 s
->intra_matrix
[j
] = ff_mpeg4_default_intra_matrix
[i
];
734 s
->inter_matrix
[j
] = ff_mpeg4_default_non_intra_matrix
[i
];
735 }else if(s
->out_format
== FMT_H263
|| s
->out_format
== FMT_H261
){
737 s
->inter_matrix
[j
] = ff_mpeg1_default_non_intra_matrix
[i
];
740 s
->intra_matrix
[j
] = ff_mpeg1_default_intra_matrix
[i
];
741 s
->inter_matrix
[j
] = ff_mpeg1_default_non_intra_matrix
[i
];
743 if(s
->avctx
->intra_matrix
)
744 s
->intra_matrix
[j
] = s
->avctx
->intra_matrix
[i
];
745 if(s
->avctx
->inter_matrix
)
746 s
->inter_matrix
[j
] = s
->avctx
->inter_matrix
[i
];
749 /* precompute matrix */
750 /* for mjpeg, we do include qscale in the matrix */
751 if (s
->out_format
!= FMT_MJPEG
) {
752 ff_convert_matrix(&s
->dsp
, s
->q_intra_matrix
, s
->q_intra_matrix16
,
753 s
->intra_matrix
, s
->intra_quant_bias
, avctx
->qmin
, 31, 1);
754 ff_convert_matrix(&s
->dsp
, s
->q_inter_matrix
, s
->q_inter_matrix16
,
755 s
->inter_matrix
, s
->inter_quant_bias
, avctx
->qmin
, 31, 0);
758 if(ff_rate_control_init(s
) < 0)
764 av_cold
int MPV_encode_end(AVCodecContext
*avctx
)
766 MpegEncContext
*s
= avctx
->priv_data
;
768 ff_rate_control_uninit(s
);
771 if ((CONFIG_MJPEG_ENCODER
|| CONFIG_LJPEG_ENCODER
) && s
->out_format
== FMT_MJPEG
)
772 ff_mjpeg_encode_close(s
);
774 av_freep(&avctx
->extradata
);
779 static int get_sae(uint8_t *src
, int ref
, int stride
){
785 acc
+= FFABS(src
[x
+y
*stride
] - ref
);
792 static int get_intra_count(MpegEncContext
*s
, uint8_t *src
, uint8_t *ref
, int stride
){
799 for(y
=0; y
<h
; y
+=16){
800 for(x
=0; x
<w
; x
+=16){
801 int offset
= x
+ y
*stride
;
802 int sad
= s
->dsp
.sad
[0](NULL
, src
+ offset
, ref
+ offset
, stride
, 16);
803 int mean
= (s
->dsp
.pix_sum(src
+ offset
, stride
) + 128)>>8;
804 int sae
= get_sae(src
+ offset
, mean
, stride
);
806 acc
+= sae
+ 500 < sad
;
813 static int load_input_picture(MpegEncContext
*s
, AVFrame
*pic_arg
){
817 const int encoding_delay
= s
->max_b_frames
;
822 pic_arg
->display_picture_number
= s
->input_picture_number
++;
824 if(pts
!= AV_NOPTS_VALUE
){
825 if(s
->user_specified_pts
!= AV_NOPTS_VALUE
){
827 int64_t last
= s
->user_specified_pts
;
830 av_log(s
->avctx
, AV_LOG_ERROR
, "Error, Invalid timestamp=%"PRId64
", last=%"PRId64
"\n", pts
, s
->user_specified_pts
);
834 s
->user_specified_pts
= pts
;
836 if(s
->user_specified_pts
!= AV_NOPTS_VALUE
){
837 s
->user_specified_pts
=
838 pts
= s
->user_specified_pts
+ 1;
839 av_log(s
->avctx
, AV_LOG_INFO
, "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n", pts
);
841 pts
= pic_arg
->display_picture_number
;
847 if(encoding_delay
&& !(s
->flags
&CODEC_FLAG_INPUT_PRESERVED
)) direct
=0;
848 if(pic_arg
->linesize
[0] != s
->linesize
) direct
=0;
849 if(pic_arg
->linesize
[1] != s
->uvlinesize
) direct
=0;
850 if(pic_arg
->linesize
[2] != s
->uvlinesize
) direct
=0;
852 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
855 i
= ff_find_unused_picture(s
, 1);
857 pic
= (AVFrame
*)&s
->picture
[i
];
861 pic
->data
[i
]= pic_arg
->data
[i
];
862 pic
->linesize
[i
]= pic_arg
->linesize
[i
];
864 if(ff_alloc_picture(s
, (Picture
*)pic
, 1) < 0){
868 i
= ff_find_unused_picture(s
, 0);
870 pic
= (AVFrame
*)&s
->picture
[i
];
873 if(ff_alloc_picture(s
, (Picture
*)pic
, 0) < 0){
877 if( pic
->data
[0] + INPLACE_OFFSET
== pic_arg
->data
[0]
878 && pic
->data
[1] + INPLACE_OFFSET
== pic_arg
->data
[1]
879 && pic
->data
[2] + INPLACE_OFFSET
== pic_arg
->data
[2]){
882 int h_chroma_shift
, v_chroma_shift
;
883 avcodec_get_chroma_sub_sample(s
->avctx
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
886 int src_stride
= pic_arg
->linesize
[i
];
887 int dst_stride
= i ? s
->uvlinesize
: s
->linesize
;
888 int h_shift
= i ? h_chroma_shift
: 0;
889 int v_shift
= i ? v_chroma_shift
: 0;
890 int w
= s
->width
>>h_shift
;
891 int h
= s
->height
>>v_shift
;
892 uint8_t *src
= pic_arg
->data
[i
];
893 uint8_t *dst
= pic
->data
[i
];
895 if(!s
->avctx
->rc_buffer_size
)
896 dst
+=INPLACE_OFFSET
;
898 if(src_stride
==dst_stride
)
899 memcpy(dst
, src
, src_stride
*h
);
910 copy_picture_attributes(s
, pic
, pic_arg
);
911 pic
->pts
= pts
; //we set this here to avoid modifiying pic_arg
914 /* shift buffer entries */
915 for(i
=1; i
<MAX_PICTURE_COUNT
/*s->encoding_delay+1*/; i
++)
916 s
->input_picture
[i
-1]= s
->input_picture
[i
];
918 s
->input_picture
[encoding_delay
]= (Picture
*)pic
;
923 static int skip_check(MpegEncContext
*s
, Picture
*p
, Picture
*ref
){
928 for(plane
=0; plane
<3; plane
++){
929 const int stride
= p
->linesize
[plane
];
930 const int bw
= plane ?
1 : 2;
931 for(y
=0; y
<s
->mb_height
*bw
; y
++){
932 for(x
=0; x
<s
->mb_width
*bw
; x
++){
933 int off
= p
->type
== FF_BUFFER_TYPE_SHARED ?
0: 16;
934 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);
936 switch(s
->avctx
->frame_skip_exp
){
937 case 0: score
= FFMAX(score
, v
); break;
938 case 1: score
+= FFABS(v
);break;
939 case 2: score
+= v
*v
;break;
940 case 3: score64
+= FFABS(v
*v
*(int64_t)v
);break;
941 case 4: score64
+= v
*v
*(int64_t)(v
*v
);break;
947 if(score
) score64
= score
;
949 if(score64
< s
->avctx
->frame_skip_threshold
)
951 if(score64
< ((s
->avctx
->frame_skip_factor
* (int64_t)s
->lambda
)>>8))
956 static int estimate_best_b_count(MpegEncContext
*s
){
957 AVCodec
*codec
= avcodec_find_encoder(s
->avctx
->codec_id
);
958 AVCodecContext
*c
= avcodec_alloc_context();
959 AVFrame input
[FF_MAX_B_FRAMES
+2];
960 const int scale
= s
->avctx
->brd_scale
;
961 int i
, j
, out_size
, p_lambda
, b_lambda
, lambda2
;
962 int outbuf_size
= s
->width
* s
->height
; //FIXME
963 uint8_t *outbuf
= av_malloc(outbuf_size
);
964 int64_t best_rd
= INT64_MAX
;
965 int best_b_count
= -1;
967 assert(scale
>=0 && scale
<=3);
970 p_lambda
= s
->last_lambda_for
[FF_P_TYPE
]; //s->next_picture_ptr->quality;
971 b_lambda
= s
->last_lambda_for
[FF_B_TYPE
]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
972 if(!b_lambda
) b_lambda
= p_lambda
; //FIXME we should do this somewhere else
973 lambda2
= (b_lambda
*b_lambda
+ (1<<FF_LAMBDA_SHIFT
)/2 ) >> FF_LAMBDA_SHIFT
;
975 c
->width
= s
->width
>> scale
;
976 c
->height
= s
->height
>> scale
;
977 c
->flags
= CODEC_FLAG_QSCALE
| CODEC_FLAG_PSNR
| CODEC_FLAG_INPUT_PRESERVED
/*| CODEC_FLAG_EMU_EDGE*/;
978 c
->flags
|= s
->avctx
->flags
& CODEC_FLAG_QPEL
;
979 c
->mb_decision
= s
->avctx
->mb_decision
;
980 c
->me_cmp
= s
->avctx
->me_cmp
;
981 c
->mb_cmp
= s
->avctx
->mb_cmp
;
982 c
->me_sub_cmp
= s
->avctx
->me_sub_cmp
;
983 c
->pix_fmt
= PIX_FMT_YUV420P
;
984 c
->time_base
= s
->avctx
->time_base
;
985 c
->max_b_frames
= s
->max_b_frames
;
987 if (avcodec_open(c
, codec
) < 0)
990 for(i
=0; i
<s
->max_b_frames
+2; i
++){
991 int ysize
= c
->width
*c
->height
;
992 int csize
= (c
->width
/2)*(c
->height
/2);
993 Picture pre_input
, *pre_input_ptr
= i ? s
->input_picture
[i
-1] : s
->next_picture_ptr
;
995 avcodec_get_frame_defaults(&input
[i
]);
996 input
[i
].data
[0]= av_malloc(ysize
+ 2*csize
);
997 input
[i
].data
[1]= input
[i
].data
[0] + ysize
;
998 input
[i
].data
[2]= input
[i
].data
[1] + csize
;
999 input
[i
].linesize
[0]= c
->width
;
1000 input
[i
].linesize
[1]=
1001 input
[i
].linesize
[2]= c
->width
/2;
1003 if(pre_input_ptr
&& (!i
|| s
->input_picture
[i
-1])) {
1004 pre_input
= *pre_input_ptr
;
1006 if(pre_input
.type
!= FF_BUFFER_TYPE_SHARED
&& i
) {
1007 pre_input
.data
[0]+=INPLACE_OFFSET
;
1008 pre_input
.data
[1]+=INPLACE_OFFSET
;
1009 pre_input
.data
[2]+=INPLACE_OFFSET
;
1012 s
->dsp
.shrink
[scale
](input
[i
].data
[0], input
[i
].linesize
[0], pre_input
.data
[0], pre_input
.linesize
[0], c
->width
, c
->height
);
1013 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);
1014 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);
1018 for(j
=0; j
<s
->max_b_frames
+1; j
++){
1021 if(!s
->input_picture
[j
])
1024 c
->error
[0]= c
->error
[1]= c
->error
[2]= 0;
1026 input
[0].pict_type
= FF_I_TYPE
;
1027 input
[0].quality
= 1 * FF_QP2LAMBDA
;
1028 out_size
= avcodec_encode_video(c
, outbuf
, outbuf_size
, &input
[0]);
1029 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1031 for(i
=0; i
<s
->max_b_frames
+1; i
++){
1032 int is_p
= i
% (j
+1) == j
|| i
==s
->max_b_frames
;
1034 input
[i
+1].pict_type
= is_p ? FF_P_TYPE
: FF_B_TYPE
;
1035 input
[i
+1].quality
= is_p ? p_lambda
: b_lambda
;
1036 out_size
= avcodec_encode_video(c
, outbuf
, outbuf_size
, &input
[i
+1]);
1037 rd
+= (out_size
* lambda2
) >> (FF_LAMBDA_SHIFT
- 3);
1040 /* get the delayed frames */
1042 out_size
= avcodec_encode_video(c
, outbuf
, outbuf_size
, NULL
);
1043 rd
+= (out_size
* lambda2
) >> (FF_LAMBDA_SHIFT
- 3);
1046 rd
+= c
->error
[0] + c
->error
[1] + c
->error
[2];
1058 for(i
=0; i
<s
->max_b_frames
+2; i
++){
1059 av_freep(&input
[i
].data
[0]);
1062 return best_b_count
;
1065 static int select_input_picture(MpegEncContext
*s
){
1068 for(i
=1; i
<MAX_PICTURE_COUNT
; i
++)
1069 s
->reordered_input_picture
[i
-1]= s
->reordered_input_picture
[i
];
1070 s
->reordered_input_picture
[MAX_PICTURE_COUNT
-1]= NULL
;
1072 /* set next picture type & ordering */
1073 if(s
->reordered_input_picture
[0]==NULL
&& s
->input_picture
[0]){
1074 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s
->next_picture_ptr
==NULL
|| s
->intra_only
){
1075 s
->reordered_input_picture
[0]= s
->input_picture
[0];
1076 s
->reordered_input_picture
[0]->pict_type
= FF_I_TYPE
;
1077 s
->reordered_input_picture
[0]->coded_picture_number
= s
->coded_picture_number
++;
1081 if(s
->avctx
->frame_skip_threshold
|| s
->avctx
->frame_skip_factor
){
1082 if(s
->picture_in_gop_number
< s
->gop_size
&& skip_check(s
, s
->input_picture
[0], s
->next_picture_ptr
)){
1083 //FIXME check that te gop check above is +-1 correct
1084 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
1086 if(s
->input_picture
[0]->type
== FF_BUFFER_TYPE_SHARED
){
1088 s
->input_picture
[0]->data
[i
]= NULL
;
1089 s
->input_picture
[0]->type
= 0;
1091 assert( s
->input_picture
[0]->type
==FF_BUFFER_TYPE_USER
1092 || s
->input_picture
[0]->type
==FF_BUFFER_TYPE_INTERNAL
);
1094 s
->avctx
->release_buffer(s
->avctx
, (AVFrame
*)s
->input_picture
[0]);
1098 ff_vbv_update(s
, 0);
1104 if(s
->flags
&CODEC_FLAG_PASS2
){
1105 for(i
=0; i
<s
->max_b_frames
+1; i
++){
1106 int pict_num
= s
->input_picture
[0]->display_picture_number
+ i
;
1108 if(pict_num
>= s
->rc_context
.num_entries
)
1110 if(!s
->input_picture
[i
]){
1111 s
->rc_context
.entry
[pict_num
-1].new_pict_type
= FF_P_TYPE
;
1115 s
->input_picture
[i
]->pict_type
=
1116 s
->rc_context
.entry
[pict_num
].new_pict_type
;
1120 if(s
->avctx
->b_frame_strategy
==0){
1121 b_frames
= s
->max_b_frames
;
1122 while(b_frames
&& !s
->input_picture
[b_frames
]) b_frames
--;
1123 }else if(s
->avctx
->b_frame_strategy
==1){
1124 for(i
=1; i
<s
->max_b_frames
+1; i
++){
1125 if(s
->input_picture
[i
] && s
->input_picture
[i
]->b_frame_score
==0){
1126 s
->input_picture
[i
]->b_frame_score
=
1127 get_intra_count(s
, s
->input_picture
[i
]->data
[0],
1128 s
->input_picture
[i
-1]->data
[0], s
->linesize
) + 1;
1131 for(i
=0; i
<s
->max_b_frames
+1; i
++){
1132 if(s
->input_picture
[i
]==NULL
|| s
->input_picture
[i
]->b_frame_score
- 1 > s
->mb_num
/s
->avctx
->b_sensitivity
) break;
1135 b_frames
= FFMAX(0, i
-1);
1138 for(i
=0; i
<b_frames
+1; i
++){
1139 s
->input_picture
[i
]->b_frame_score
=0;
1141 }else if(s
->avctx
->b_frame_strategy
==2){
1142 b_frames
= estimate_best_b_count(s
);
1144 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal b frame strategy\n");
1149 //static int b_count=0;
1150 //b_count+= b_frames;
1151 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1153 for(i
= b_frames
- 1; i
>=0; i
--){
1154 int type
= s
->input_picture
[i
]->pict_type
;
1155 if(type
&& type
!= FF_B_TYPE
)
1158 if(s
->input_picture
[b_frames
]->pict_type
== FF_B_TYPE
&& b_frames
== s
->max_b_frames
){
1159 av_log(s
->avctx
, AV_LOG_ERROR
, "warning, too many b frames in a row\n");
1162 if(s
->picture_in_gop_number
+ b_frames
>= s
->gop_size
){
1163 if((s
->flags2
& CODEC_FLAG2_STRICT_GOP
) && s
->gop_size
> s
->picture_in_gop_number
){
1164 b_frames
= s
->gop_size
- s
->picture_in_gop_number
- 1;
1166 if(s
->flags
& CODEC_FLAG_CLOSED_GOP
)
1168 s
->input_picture
[b_frames
]->pict_type
= FF_I_TYPE
;
1172 if( (s
->flags
& CODEC_FLAG_CLOSED_GOP
)
1174 && s
->input_picture
[b_frames
]->pict_type
== FF_I_TYPE
)
1177 s
->reordered_input_picture
[0]= s
->input_picture
[b_frames
];
1178 if(s
->reordered_input_picture
[0]->pict_type
!= FF_I_TYPE
)
1179 s
->reordered_input_picture
[0]->pict_type
= FF_P_TYPE
;
1180 s
->reordered_input_picture
[0]->coded_picture_number
= s
->coded_picture_number
++;
1181 for(i
=0; i
<b_frames
; i
++){
1182 s
->reordered_input_picture
[i
+1]= s
->input_picture
[i
];
1183 s
->reordered_input_picture
[i
+1]->pict_type
= FF_B_TYPE
;
1184 s
->reordered_input_picture
[i
+1]->coded_picture_number
= s
->coded_picture_number
++;
1189 if(s
->reordered_input_picture
[0]){
1190 s
->reordered_input_picture
[0]->reference
= s
->reordered_input_picture
[0]->pict_type
!=FF_B_TYPE ?
3 : 0;
1192 ff_copy_picture(&s
->new_picture
, s
->reordered_input_picture
[0]);
1194 if(s
->reordered_input_picture
[0]->type
== FF_BUFFER_TYPE_SHARED
|| s
->avctx
->rc_buffer_size
){
1195 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
1197 int i
= ff_find_unused_picture(s
, 0);
1198 Picture
*pic
= &s
->picture
[i
];
1200 pic
->reference
= s
->reordered_input_picture
[0]->reference
;
1201 if(ff_alloc_picture(s
, pic
, 0) < 0){
1205 /* mark us unused / free shared pic */
1206 if(s
->reordered_input_picture
[0]->type
== FF_BUFFER_TYPE_INTERNAL
)
1207 s
->avctx
->release_buffer(s
->avctx
, (AVFrame
*)s
->reordered_input_picture
[0]);
1209 s
->reordered_input_picture
[0]->data
[i
]= NULL
;
1210 s
->reordered_input_picture
[0]->type
= 0;
1212 copy_picture_attributes(s
, (AVFrame
*)pic
, (AVFrame
*)s
->reordered_input_picture
[0]);
1214 s
->current_picture_ptr
= pic
;
1216 // input is not a shared pix -> reuse buffer for current_pix
1218 assert( s
->reordered_input_picture
[0]->type
==FF_BUFFER_TYPE_USER
1219 || s
->reordered_input_picture
[0]->type
==FF_BUFFER_TYPE_INTERNAL
);
1221 s
->current_picture_ptr
= s
->reordered_input_picture
[0];
1223 s
->new_picture
.data
[i
]+= INPLACE_OFFSET
;
1226 ff_copy_picture(&s
->current_picture
, s
->current_picture_ptr
);
1228 s
->picture_number
= s
->new_picture
.display_picture_number
;
1229 //printf("dpn:%d\n", s->picture_number);
1231 memset(&s
->new_picture
, 0, sizeof(Picture
));
1236 int MPV_encode_picture(AVCodecContext
*avctx
,
1237 unsigned char *buf
, int buf_size
, void *data
)
1239 MpegEncContext
*s
= avctx
->priv_data
;
1240 AVFrame
*pic_arg
= data
;
1241 int i
, stuffing_count
;
1243 for(i
=0; i
<avctx
->thread_count
; i
++){
1244 int start_y
= s
->thread_context
[i
]->start_mb_y
;
1245 int end_y
= s
->thread_context
[i
]-> end_mb_y
;
1246 int h
= s
->mb_height
;
1247 uint8_t *start
= buf
+ (size_t)(((int64_t) buf_size
)*start_y
/h
);
1248 uint8_t *end
= buf
+ (size_t)(((int64_t) buf_size
)* end_y
/h
);
1250 init_put_bits(&s
->thread_context
[i
]->pb
, start
, end
- start
);
1253 s
->picture_in_gop_number
++;
1255 if(load_input_picture(s
, pic_arg
) < 0)
1258 if(select_input_picture(s
) < 0){
1263 if(s
->new_picture
.data
[0]){
1264 s
->pict_type
= s
->new_picture
.pict_type
;
1266 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1267 MPV_frame_start(s
, avctx
);
1269 if (encode_picture(s
, s
->picture_number
) < 0)
1272 avctx
->header_bits
= s
->header_bits
;
1273 avctx
->mv_bits
= s
->mv_bits
;
1274 avctx
->misc_bits
= s
->misc_bits
;
1275 avctx
->i_tex_bits
= s
->i_tex_bits
;
1276 avctx
->p_tex_bits
= s
->p_tex_bits
;
1277 avctx
->i_count
= s
->i_count
;
1278 avctx
->p_count
= s
->mb_num
- s
->i_count
- s
->skip_count
; //FIXME f/b_count in avctx
1279 avctx
->skip_count
= s
->skip_count
;
1283 if (CONFIG_MJPEG_ENCODER
&& s
->out_format
== FMT_MJPEG
)
1284 ff_mjpeg_encode_picture_trailer(s
);
1286 if(avctx
->rc_buffer_size
){
1287 RateControlContext
*rcc
= &s
->rc_context
;
1288 int max_size
= rcc
->buffer_index
* avctx
->rc_max_available_vbv_use
;
1290 if(put_bits_count(&s
->pb
) > max_size
&& s
->lambda
< s
->avctx
->lmax
){
1291 s
->next_lambda
= FFMAX(s
->lambda
+1, s
->lambda
*(s
->qscale
+1) / s
->qscale
);
1292 if(s
->adaptive_quant
){
1294 for(i
=0; i
<s
->mb_height
*s
->mb_stride
; i
++)
1295 s
->lambda_table
[i
]= FFMAX(s
->lambda_table
[i
]+1, s
->lambda_table
[i
]*(s
->qscale
+1) / s
->qscale
);
1297 s
->mb_skipped
= 0; //done in MPV_frame_start()
1298 if(s
->pict_type
==FF_P_TYPE
){ //done in encode_picture() so we must undo it
1299 if(s
->flipflop_rounding
|| s
->codec_id
== CODEC_ID_H263P
|| s
->codec_id
== CODEC_ID_MPEG4
)
1300 s
->no_rounding
^= 1;
1302 if(s
->pict_type
!=FF_B_TYPE
){
1303 s
->time_base
= s
->last_time_base
;
1304 s
->last_non_b_time
= s
->time
- s
->pp_time
;
1306 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1307 for(i
=0; i
<avctx
->thread_count
; i
++){
1308 PutBitContext
*pb
= &s
->thread_context
[i
]->pb
;
1309 init_put_bits(pb
, pb
->buf
, pb
->buf_end
- pb
->buf
);
1314 assert(s
->avctx
->rc_max_rate
);
1317 if(s
->flags
&CODEC_FLAG_PASS1
)
1318 ff_write_pass1_stats(s
);
1321 s
->current_picture_ptr
->error
[i
]= s
->current_picture
.error
[i
];
1322 avctx
->error
[i
] += s
->current_picture_ptr
->error
[i
];
1325 if(s
->flags
&CODEC_FLAG_PASS1
)
1326 assert(avctx
->header_bits
+ avctx
->mv_bits
+ avctx
->misc_bits
+ avctx
->i_tex_bits
+ avctx
->p_tex_bits
== put_bits_count(&s
->pb
));
1327 flush_put_bits(&s
->pb
);
1328 s
->frame_bits
= put_bits_count(&s
->pb
);
1330 stuffing_count
= ff_vbv_update(s
, s
->frame_bits
);
1332 if(s
->pb
.buf_end
- s
->pb
.buf
- (put_bits_count(&s
->pb
)>>3) < stuffing_count
+ 50){
1333 av_log(s
->avctx
, AV_LOG_ERROR
, "stuffing too large\n");
1337 switch(s
->codec_id
){
1338 case CODEC_ID_MPEG1VIDEO
:
1339 case CODEC_ID_MPEG2VIDEO
:
1340 while(stuffing_count
--){
1341 put_bits(&s
->pb
, 8, 0);
1344 case CODEC_ID_MPEG4
:
1345 put_bits(&s
->pb
, 16, 0);
1346 put_bits(&s
->pb
, 16, 0x1C3);
1347 stuffing_count
-= 4;
1348 while(stuffing_count
--){
1349 put_bits(&s
->pb
, 8, 0xFF);
1353 av_log(s
->avctx
, AV_LOG_ERROR
, "vbv buffer overflow\n");
1355 flush_put_bits(&s
->pb
);
1356 s
->frame_bits
= put_bits_count(&s
->pb
);
1359 /* update mpeg1/2 vbv_delay for CBR */
1360 if(s
->avctx
->rc_max_rate
&& s
->avctx
->rc_min_rate
== s
->avctx
->rc_max_rate
&& s
->out_format
== FMT_MPEG1
1361 && 90000LL * (avctx
->rc_buffer_size
-1) <= s
->avctx
->rc_max_rate
*0xFFFFLL
){
1362 int vbv_delay
, min_delay
;
1363 double inbits
= s
->avctx
->rc_max_rate
*av_q2d(s
->avctx
->time_base
);
1364 int minbits
= s
->frame_bits
- 8*(s
->vbv_delay_ptr
- s
->pb
.buf
- 1);
1365 double bits
= s
->rc_context
.buffer_index
+ minbits
- inbits
;
1368 av_log(s
->avctx
, AV_LOG_ERROR
, "Internal error, negative bits\n");
1370 assert(s
->repeat_first_field
==0);
1372 vbv_delay
= bits
* 90000 / s
->avctx
->rc_max_rate
;
1373 min_delay
= (minbits
* 90000LL + s
->avctx
->rc_max_rate
- 1)/ s
->avctx
->rc_max_rate
;
1375 vbv_delay
= FFMAX(vbv_delay
, min_delay
);
1377 assert(vbv_delay
< 0xFFFF);
1379 s
->vbv_delay_ptr
[0] &= 0xF8;
1380 s
->vbv_delay_ptr
[0] |= vbv_delay
>>13;
1381 s
->vbv_delay_ptr
[1] = vbv_delay
>>5;
1382 s
->vbv_delay_ptr
[2] &= 0x07;
1383 s
->vbv_delay_ptr
[2] |= vbv_delay
<<3;
1385 s
->total_bits
+= s
->frame_bits
;
1386 avctx
->frame_bits
= s
->frame_bits
;
1388 assert((put_bits_ptr(&s
->pb
) == s
->pb
.buf
));
1391 assert((s
->frame_bits
&7)==0);
1393 return s
->frame_bits
/8;
1396 static inline void dct_single_coeff_elimination(MpegEncContext
*s
, int n
, int threshold
)
1398 static const char tab
[64]=
1410 DCTELEM
*block
= s
->block
[n
];
1411 const int last_index
= s
->block_last_index
[n
];
1416 threshold
= -threshold
;
1420 /* Are all we could set to zero already zero? */
1421 if(last_index
<=skip_dc
- 1) return;
1423 for(i
=0; i
<=last_index
; i
++){
1424 const int j
= s
->intra_scantable
.permutated
[i
];
1425 const int level
= FFABS(block
[j
]);
1427 if(skip_dc
&& i
==0) continue;
1436 if(score
>= threshold
) return;
1437 for(i
=skip_dc
; i
<=last_index
; i
++){
1438 const int j
= s
->intra_scantable
.permutated
[i
];
1441 if(block
[0]) s
->block_last_index
[n
]= 0;
1442 else s
->block_last_index
[n
]= -1;
1445 static inline void clip_coeffs(MpegEncContext
*s
, DCTELEM
*block
, int last_index
)
1448 const int maxlevel
= s
->max_qcoeff
;
1449 const int minlevel
= s
->min_qcoeff
;
1453 i
=1; //skip clipping of intra dc
1457 for(;i
<=last_index
; i
++){
1458 const int j
= s
->intra_scantable
.permutated
[i
];
1459 int level
= block
[j
];
1461 if (level
>maxlevel
){
1464 }else if(level
<minlevel
){
1472 if(overflow
&& s
->avctx
->mb_decision
== FF_MB_DECISION_SIMPLE
)
1473 av_log(s
->avctx
, AV_LOG_INFO
, "warning, clipping %d dct coefficients to %d..%d\n", overflow
, minlevel
, maxlevel
);
1476 static void get_visual_weight(int16_t *weight
, uint8_t *ptr
, int stride
){
1486 for(y2
= FFMAX(y
-1, 0); y2
< FFMIN(8, y
+2); y2
++){
1487 for(x2
= FFMAX(x
-1, 0); x2
< FFMIN(8, x
+2); x2
++){
1488 int v
= ptr
[x2
+ y2
*stride
];
1494 weight
[x
+ 8*y
]= (36*ff_sqrt(count
*sqr
- sum
*sum
)) / count
;
1499 static av_always_inline
void encode_mb_internal(MpegEncContext
*s
, int motion_x
, int motion_y
, int mb_block_height
, int mb_block_count
)
1501 int16_t weight
[8][64];
1502 DCTELEM orig
[8][64];
1503 const int mb_x
= s
->mb_x
;
1504 const int mb_y
= s
->mb_y
;
1507 int dct_offset
= s
->linesize
*8; //default for progressive frames
1508 uint8_t *ptr_y
, *ptr_cb
, *ptr_cr
;
1511 for(i
=0; i
<mb_block_count
; i
++) skip_dct
[i
]=s
->skipdct
;
1513 if(s
->adaptive_quant
){
1514 const int last_qp
= s
->qscale
;
1515 const int mb_xy
= mb_x
+ mb_y
*s
->mb_stride
;
1517 s
->lambda
= s
->lambda_table
[mb_xy
];
1520 if(!(s
->flags
&CODEC_FLAG_QP_RD
)){
1521 s
->qscale
= s
->current_picture_ptr
->qscale_table
[mb_xy
];
1522 s
->dquant
= s
->qscale
- last_qp
;
1524 if(s
->out_format
==FMT_H263
){
1525 s
->dquant
= av_clip(s
->dquant
, -2, 2);
1527 if(s
->codec_id
==CODEC_ID_MPEG4
){
1529 if(s
->pict_type
== FF_B_TYPE
){
1530 if(s
->dquant
&1 || s
->mv_dir
&MV_DIRECT
)
1533 if(s
->mv_type
==MV_TYPE_8X8
)
1539 ff_set_qscale(s
, last_qp
+ s
->dquant
);
1540 }else if(s
->flags
&CODEC_FLAG_QP_RD
)
1541 ff_set_qscale(s
, s
->qscale
+ s
->dquant
);
1543 wrap_y
= s
->linesize
;
1544 wrap_c
= s
->uvlinesize
;
1545 ptr_y
= s
->new_picture
.data
[0] + (mb_y
* 16 * wrap_y
) + mb_x
* 16;
1546 ptr_cb
= s
->new_picture
.data
[1] + (mb_y
* mb_block_height
* wrap_c
) + mb_x
* 8;
1547 ptr_cr
= s
->new_picture
.data
[2] + (mb_y
* mb_block_height
* wrap_c
) + mb_x
* 8;
1549 if(mb_x
*16+16 > s
->width
|| mb_y
*16+16 > s
->height
){
1550 uint8_t *ebuf
= s
->edge_emu_buffer
+ 32;
1551 ff_emulated_edge_mc(ebuf
, ptr_y
, wrap_y
,16,16,mb_x
*16,mb_y
*16, s
->width
, s
->height
);
1553 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);
1554 ptr_cb
= ebuf
+18*wrap_y
;
1555 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);
1556 ptr_cr
= ebuf
+18*wrap_y
+8;
1560 if(s
->flags
&CODEC_FLAG_INTERLACED_DCT
){
1561 int progressive_score
, interlaced_score
;
1563 s
->interlaced_dct
=0;
1564 progressive_score
= s
->dsp
.ildct_cmp
[4](s
, ptr_y
, NULL
, wrap_y
, 8)
1565 +s
->dsp
.ildct_cmp
[4](s
, ptr_y
+ wrap_y
*8, NULL
, wrap_y
, 8) - 400;
1567 if(progressive_score
> 0){
1568 interlaced_score
= s
->dsp
.ildct_cmp
[4](s
, ptr_y
, NULL
, wrap_y
*2, 8)
1569 +s
->dsp
.ildct_cmp
[4](s
, ptr_y
+ wrap_y
, NULL
, wrap_y
*2, 8);
1570 if(progressive_score
> interlaced_score
){
1571 s
->interlaced_dct
=1;
1575 if (s
->chroma_format
== CHROMA_422
)
1581 s
->dsp
.get_pixels(s
->block
[0], ptr_y
, wrap_y
);
1582 s
->dsp
.get_pixels(s
->block
[1], ptr_y
+ 8, wrap_y
);
1583 s
->dsp
.get_pixels(s
->block
[2], ptr_y
+ dct_offset
, wrap_y
);
1584 s
->dsp
.get_pixels(s
->block
[3], ptr_y
+ dct_offset
+ 8, wrap_y
);
1586 if(s
->flags
&CODEC_FLAG_GRAY
){
1590 s
->dsp
.get_pixels(s
->block
[4], ptr_cb
, wrap_c
);
1591 s
->dsp
.get_pixels(s
->block
[5], ptr_cr
, wrap_c
);
1592 if(!s
->chroma_y_shift
){ /* 422 */
1593 s
->dsp
.get_pixels(s
->block
[6], ptr_cb
+ (dct_offset
>>1), wrap_c
);
1594 s
->dsp
.get_pixels(s
->block
[7], ptr_cr
+ (dct_offset
>>1), wrap_c
);
1598 op_pixels_func (*op_pix
)[4];
1599 qpel_mc_func (*op_qpix
)[16];
1600 uint8_t *dest_y
, *dest_cb
, *dest_cr
;
1602 dest_y
= s
->dest
[0];
1603 dest_cb
= s
->dest
[1];
1604 dest_cr
= s
->dest
[2];
1606 if ((!s
->no_rounding
) || s
->pict_type
==FF_B_TYPE
){
1607 op_pix
= s
->dsp
.put_pixels_tab
;
1608 op_qpix
= s
->dsp
.put_qpel_pixels_tab
;
1610 op_pix
= s
->dsp
.put_no_rnd_pixels_tab
;
1611 op_qpix
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
1614 if (s
->mv_dir
& MV_DIR_FORWARD
) {
1615 MPV_motion(s
, dest_y
, dest_cb
, dest_cr
, 0, s
->last_picture
.data
, op_pix
, op_qpix
);
1616 op_pix
= s
->dsp
.avg_pixels_tab
;
1617 op_qpix
= s
->dsp
.avg_qpel_pixels_tab
;
1619 if (s
->mv_dir
& MV_DIR_BACKWARD
) {
1620 MPV_motion(s
, dest_y
, dest_cb
, dest_cr
, 1, s
->next_picture
.data
, op_pix
, op_qpix
);
1623 if(s
->flags
&CODEC_FLAG_INTERLACED_DCT
){
1624 int progressive_score
, interlaced_score
;
1626 s
->interlaced_dct
=0;
1627 progressive_score
= s
->dsp
.ildct_cmp
[0](s
, dest_y
, ptr_y
, wrap_y
, 8)
1628 +s
->dsp
.ildct_cmp
[0](s
, dest_y
+ wrap_y
*8, ptr_y
+ wrap_y
*8, wrap_y
, 8) - 400;
1630 if(s
->avctx
->ildct_cmp
== FF_CMP_VSSE
) progressive_score
-= 400;
1632 if(progressive_score
>0){
1633 interlaced_score
= s
->dsp
.ildct_cmp
[0](s
, dest_y
, ptr_y
, wrap_y
*2, 8)
1634 +s
->dsp
.ildct_cmp
[0](s
, dest_y
+ wrap_y
, ptr_y
+ wrap_y
, wrap_y
*2, 8);
1636 if(progressive_score
> interlaced_score
){
1637 s
->interlaced_dct
=1;
1641 if (s
->chroma_format
== CHROMA_422
)
1647 s
->dsp
.diff_pixels(s
->block
[0], ptr_y
, dest_y
, wrap_y
);
1648 s
->dsp
.diff_pixels(s
->block
[1], ptr_y
+ 8, dest_y
+ 8, wrap_y
);
1649 s
->dsp
.diff_pixels(s
->block
[2], ptr_y
+ dct_offset
, dest_y
+ dct_offset
, wrap_y
);
1650 s
->dsp
.diff_pixels(s
->block
[3], ptr_y
+ dct_offset
+ 8, dest_y
+ dct_offset
+ 8, wrap_y
);
1652 if(s
->flags
&CODEC_FLAG_GRAY
){
1656 s
->dsp
.diff_pixels(s
->block
[4], ptr_cb
, dest_cb
, wrap_c
);
1657 s
->dsp
.diff_pixels(s
->block
[5], ptr_cr
, dest_cr
, wrap_c
);
1658 if(!s
->chroma_y_shift
){ /* 422 */
1659 s
->dsp
.diff_pixels(s
->block
[6], ptr_cb
+ (dct_offset
>>1), dest_cb
+ (dct_offset
>>1), wrap_c
);
1660 s
->dsp
.diff_pixels(s
->block
[7], ptr_cr
+ (dct_offset
>>1), dest_cr
+ (dct_offset
>>1), wrap_c
);
1663 /* pre quantization */
1664 if(s
->current_picture
.mc_mb_var
[s
->mb_stride
*mb_y
+ mb_x
]<2*s
->qscale
*s
->qscale
){
1666 if(s
->dsp
.sad
[1](NULL
, ptr_y
, dest_y
, wrap_y
, 8) < 20*s
->qscale
) skip_dct
[0]= 1;
1667 if(s
->dsp
.sad
[1](NULL
, ptr_y
+ 8, dest_y
+ 8, wrap_y
, 8) < 20*s
->qscale
) skip_dct
[1]= 1;
1668 if(s
->dsp
.sad
[1](NULL
, ptr_y
+dct_offset
, dest_y
+dct_offset
, wrap_y
, 8) < 20*s
->qscale
) skip_dct
[2]= 1;
1669 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;
1670 if(s
->dsp
.sad
[1](NULL
, ptr_cb
, dest_cb
, wrap_c
, 8) < 20*s
->qscale
) skip_dct
[4]= 1;
1671 if(s
->dsp
.sad
[1](NULL
, ptr_cr
, dest_cr
, wrap_c
, 8) < 20*s
->qscale
) skip_dct
[5]= 1;
1672 if(!s
->chroma_y_shift
){ /* 422 */
1673 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;
1674 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;
1679 if(s
->avctx
->quantizer_noise_shaping
){
1680 if(!skip_dct
[0]) get_visual_weight(weight
[0], ptr_y
, wrap_y
);
1681 if(!skip_dct
[1]) get_visual_weight(weight
[1], ptr_y
+ 8, wrap_y
);
1682 if(!skip_dct
[2]) get_visual_weight(weight
[2], ptr_y
+ dct_offset
, wrap_y
);
1683 if(!skip_dct
[3]) get_visual_weight(weight
[3], ptr_y
+ dct_offset
+ 8, wrap_y
);
1684 if(!skip_dct
[4]) get_visual_weight(weight
[4], ptr_cb
, wrap_c
);
1685 if(!skip_dct
[5]) get_visual_weight(weight
[5], ptr_cr
, wrap_c
);
1686 if(!s
->chroma_y_shift
){ /* 422 */
1687 if(!skip_dct
[6]) get_visual_weight(weight
[6], ptr_cb
+ (dct_offset
>>1), wrap_c
);
1688 if(!skip_dct
[7]) get_visual_weight(weight
[7], ptr_cr
+ (dct_offset
>>1), wrap_c
);
1690 memcpy(orig
[0], s
->block
[0], sizeof(DCTELEM
)*64*mb_block_count
);
1693 /* DCT & quantize */
1694 assert(s
->out_format
!=FMT_MJPEG
|| s
->qscale
==8);
1696 for(i
=0;i
<mb_block_count
;i
++) {
1699 s
->block_last_index
[i
] = s
->dct_quantize(s
, s
->block
[i
], i
, s
->qscale
, &overflow
);
1700 // FIXME we could decide to change to quantizer instead of clipping
1701 // JS: I don't think that would be a good idea it could lower quality instead
1702 // of improve it. Just INTRADC clipping deserves changes in quantizer
1703 if (overflow
) clip_coeffs(s
, s
->block
[i
], s
->block_last_index
[i
]);
1705 s
->block_last_index
[i
]= -1;
1707 if(s
->avctx
->quantizer_noise_shaping
){
1708 for(i
=0;i
<mb_block_count
;i
++) {
1710 s
->block_last_index
[i
] = dct_quantize_refine(s
, s
->block
[i
], weight
[i
], orig
[i
], i
, s
->qscale
);
1715 if(s
->luma_elim_threshold
&& !s
->mb_intra
)
1717 dct_single_coeff_elimination(s
, i
, s
->luma_elim_threshold
);
1718 if(s
->chroma_elim_threshold
&& !s
->mb_intra
)
1719 for(i
=4; i
<mb_block_count
; i
++)
1720 dct_single_coeff_elimination(s
, i
, s
->chroma_elim_threshold
);
1722 if(s
->flags
& CODEC_FLAG_CBP_RD
){
1723 for(i
=0;i
<mb_block_count
;i
++) {
1724 if(s
->block_last_index
[i
] == -1)
1725 s
->coded_score
[i
]= INT_MAX
/256;
1730 if((s
->flags
&CODEC_FLAG_GRAY
) && s
->mb_intra
){
1731 s
->block_last_index
[4]=
1732 s
->block_last_index
[5]= 0;
1734 s
->block
[5][0]= (1024 + s
->c_dc_scale
/2)/ s
->c_dc_scale
;
1737 //non c quantize code returns incorrect block_last_index FIXME
1738 if(s
->alternate_scan
&& s
->dct_quantize
!= dct_quantize_c
){
1739 for(i
=0; i
<mb_block_count
; i
++){
1741 if(s
->block_last_index
[i
]>0){
1742 for(j
=63; j
>0; j
--){
1743 if(s
->block
[i
][ s
->intra_scantable
.permutated
[j
] ]) break;
1745 s
->block_last_index
[i
]= j
;
1750 /* huffman encode */
1751 switch(s
->codec_id
){ //FIXME funct ptr could be slightly faster
1752 case CODEC_ID_MPEG1VIDEO
:
1753 case CODEC_ID_MPEG2VIDEO
:
1754 if (CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
)
1755 mpeg1_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1757 case CODEC_ID_MPEG4
:
1758 if (CONFIG_MPEG4_ENCODER
)
1759 mpeg4_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1761 case CODEC_ID_MSMPEG4V2
:
1762 case CODEC_ID_MSMPEG4V3
:
1764 if (CONFIG_MSMPEG4_ENCODER
)
1765 msmpeg4_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1768 if (CONFIG_WMV2_ENCODER
)
1769 ff_wmv2_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1772 if (CONFIG_H261_ENCODER
)
1773 ff_h261_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1776 case CODEC_ID_H263P
:
1780 if (CONFIG_H263_ENCODER
)
1781 h263_encode_mb(s
, s
->block
, motion_x
, motion_y
);
1783 case CODEC_ID_MJPEG
:
1784 if (CONFIG_MJPEG_ENCODER
)
1785 ff_mjpeg_encode_mb(s
, s
->block
);
1792 static av_always_inline
void encode_mb(MpegEncContext
*s
, int motion_x
, int motion_y
)
1794 if (s
->chroma_format
== CHROMA_420
) encode_mb_internal(s
, motion_x
, motion_y
, 8, 6);
1795 else encode_mb_internal(s
, motion_x
, motion_y
, 16, 8);
1798 static inline void copy_context_before_encode(MpegEncContext
*d
, MpegEncContext
*s
, int type
){
1801 memcpy(d
->last_mv
, s
->last_mv
, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1804 d
->mb_skip_run
= s
->mb_skip_run
;
1806 d
->last_dc
[i
]= s
->last_dc
[i
];
1809 d
->mv_bits
= s
->mv_bits
;
1810 d
->i_tex_bits
= s
->i_tex_bits
;
1811 d
->p_tex_bits
= s
->p_tex_bits
;
1812 d
->i_count
= s
->i_count
;
1813 d
->f_count
= s
->f_count
;
1814 d
->b_count
= s
->b_count
;
1815 d
->skip_count
= s
->skip_count
;
1816 d
->misc_bits
= s
->misc_bits
;
1820 d
->qscale
= s
->qscale
;
1821 d
->dquant
= s
->dquant
;
1823 d
->esc3_level_length
= s
->esc3_level_length
;
1826 static inline void copy_context_after_encode(MpegEncContext
*d
, MpegEncContext
*s
, int type
){
1829 memcpy(d
->mv
, s
->mv
, 2*4*2*sizeof(int));
1830 memcpy(d
->last_mv
, s
->last_mv
, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1833 d
->mb_skip_run
= s
->mb_skip_run
;
1835 d
->last_dc
[i
]= s
->last_dc
[i
];
1838 d
->mv_bits
= s
->mv_bits
;
1839 d
->i_tex_bits
= s
->i_tex_bits
;
1840 d
->p_tex_bits
= s
->p_tex_bits
;
1841 d
->i_count
= s
->i_count
;
1842 d
->f_count
= s
->f_count
;
1843 d
->b_count
= s
->b_count
;
1844 d
->skip_count
= s
->skip_count
;
1845 d
->misc_bits
= s
->misc_bits
;
1847 d
->mb_intra
= s
->mb_intra
;
1848 d
->mb_skipped
= s
->mb_skipped
;
1849 d
->mv_type
= s
->mv_type
;
1850 d
->mv_dir
= s
->mv_dir
;
1852 if(s
->data_partitioning
){
1854 d
->tex_pb
= s
->tex_pb
;
1858 d
->block_last_index
[i
]= s
->block_last_index
[i
];
1859 d
->interlaced_dct
= s
->interlaced_dct
;
1860 d
->qscale
= s
->qscale
;
1862 d
->esc3_level_length
= s
->esc3_level_length
;
1865 static inline void encode_mb_hq(MpegEncContext
*s
, MpegEncContext
*backup
, MpegEncContext
*best
, int type
,
1866 PutBitContext pb
[2], PutBitContext pb2
[2], PutBitContext tex_pb
[2],
1867 int *dmin
, int *next_block
, int motion_x
, int motion_y
)
1870 uint8_t *dest_backup
[3];
1872 copy_context_before_encode(s
, backup
, type
);
1874 s
->block
= s
->blocks
[*next_block
];
1875 s
->pb
= pb
[*next_block
];
1876 if(s
->data_partitioning
){
1877 s
->pb2
= pb2
[*next_block
];
1878 s
->tex_pb
= tex_pb
[*next_block
];
1882 memcpy(dest_backup
, s
->dest
, sizeof(s
->dest
));
1883 s
->dest
[0] = s
->rd_scratchpad
;
1884 s
->dest
[1] = s
->rd_scratchpad
+ 16*s
->linesize
;
1885 s
->dest
[2] = s
->rd_scratchpad
+ 16*s
->linesize
+ 8;
1886 assert(s
->linesize
>= 32); //FIXME
1889 encode_mb(s
, motion_x
, motion_y
);
1891 score
= put_bits_count(&s
->pb
);
1892 if(s
->data_partitioning
){
1893 score
+= put_bits_count(&s
->pb2
);
1894 score
+= put_bits_count(&s
->tex_pb
);
1897 if(s
->avctx
->mb_decision
== FF_MB_DECISION_RD
){
1898 MPV_decode_mb(s
, s
->block
);
1900 score
*= s
->lambda2
;
1901 score
+= sse_mb(s
) << FF_LAMBDA_SHIFT
;
1905 memcpy(s
->dest
, dest_backup
, sizeof(s
->dest
));
1912 copy_context_after_encode(best
, s
, type
);
1916 static int sse(MpegEncContext
*s
, uint8_t *src1
, uint8_t *src2
, int w
, int h
, int stride
){
1917 uint32_t *sq
= ff_squareTbl
+ 256;
1922 return s
->dsp
.sse
[0](NULL
, src1
, src2
, stride
, 16);
1923 else if(w
==8 && h
==8)
1924 return s
->dsp
.sse
[1](NULL
, src1
, src2
, stride
, 8);
1928 acc
+= sq
[src1
[x
+ y
*stride
] - src2
[x
+ y
*stride
]];
1937 static int sse_mb(MpegEncContext
*s
){
1941 if(s
->mb_x
*16 + 16 > s
->width
) w
= s
->width
- s
->mb_x
*16;
1942 if(s
->mb_y
*16 + 16 > s
->height
) h
= s
->height
- s
->mb_y
*16;
1945 if(s
->avctx
->mb_cmp
== FF_CMP_NSSE
){
1946 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)
1947 +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)
1948 +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);
1950 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)
1951 +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)
1952 +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);
1955 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
)
1956 +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
)
1957 +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
);
1960 static int pre_estimate_motion_thread(AVCodecContext
*c
, void *arg
){
1961 MpegEncContext
*s
= *(void**)arg
;
1965 s
->me
.dia_size
= s
->avctx
->pre_dia_size
;
1966 s
->first_slice_line
=1;
1967 for(s
->mb_y
= s
->end_mb_y
-1; s
->mb_y
>= s
->start_mb_y
; s
->mb_y
--) {
1968 for(s
->mb_x
=s
->mb_width
-1; s
->mb_x
>=0 ;s
->mb_x
--) {
1969 ff_pre_estimate_p_frame_motion(s
, s
->mb_x
, s
->mb_y
);
1971 s
->first_slice_line
=0;
1979 static int estimate_motion_thread(AVCodecContext
*c
, void *arg
){
1980 MpegEncContext
*s
= *(void**)arg
;
1982 ff_check_alignment();
1984 s
->me
.dia_size
= s
->avctx
->dia_size
;
1985 s
->first_slice_line
=1;
1986 for(s
->mb_y
= s
->start_mb_y
; s
->mb_y
< s
->end_mb_y
; s
->mb_y
++) {
1987 s
->mb_x
=0; //for block init below
1988 ff_init_block_index(s
);
1989 for(s
->mb_x
=0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
1990 s
->block_index
[0]+=2;
1991 s
->block_index
[1]+=2;
1992 s
->block_index
[2]+=2;
1993 s
->block_index
[3]+=2;
1995 /* compute motion vector & mb_type and store in context */
1996 if(s
->pict_type
==FF_B_TYPE
)
1997 ff_estimate_b_frame_motion(s
, s
->mb_x
, s
->mb_y
);
1999 ff_estimate_p_frame_motion(s
, s
->mb_x
, s
->mb_y
);
2001 s
->first_slice_line
=0;
2006 static int mb_var_thread(AVCodecContext
*c
, void *arg
){
2007 MpegEncContext
*s
= *(void**)arg
;
2010 ff_check_alignment();
2012 for(mb_y
=s
->start_mb_y
; mb_y
< s
->end_mb_y
; mb_y
++) {
2013 for(mb_x
=0; mb_x
< s
->mb_width
; mb_x
++) {
2016 uint8_t *pix
= s
->new_picture
.data
[0] + (yy
* s
->linesize
) + xx
;
2018 int sum
= s
->dsp
.pix_sum(pix
, s
->linesize
);
2020 varc
= (s
->dsp
.pix_norm1(pix
, s
->linesize
) - (((unsigned)(sum
*sum
))>>8) + 500 + 128)>>8;
2022 s
->current_picture
.mb_var
[s
->mb_stride
* mb_y
+ mb_x
] = varc
;
2023 s
->current_picture
.mb_mean
[s
->mb_stride
* mb_y
+ mb_x
] = (sum
+128)>>8;
2024 s
->me
.mb_var_sum_temp
+= varc
;
2030 static void write_slice_end(MpegEncContext
*s
){
2031 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
==CODEC_ID_MPEG4
){
2032 if(s
->partitioned_frame
){
2033 ff_mpeg4_merge_partitions(s
);
2036 ff_mpeg4_stuffing(&s
->pb
);
2037 }else if(CONFIG_MJPEG_ENCODER
&& s
->out_format
== FMT_MJPEG
){
2038 ff_mjpeg_encode_stuffing(&s
->pb
);
2041 align_put_bits(&s
->pb
);
2042 flush_put_bits(&s
->pb
);
2044 if((s
->flags
&CODEC_FLAG_PASS1
) && !s
->partitioned_frame
)
2045 s
->misc_bits
+= get_bits_diff(s
);
2048 static int encode_thread(AVCodecContext
*c
, void *arg
){
2049 MpegEncContext
*s
= *(void**)arg
;
2050 int mb_x
, mb_y
, pdif
= 0;
2051 int chr_h
= 16>>s
->chroma_y_shift
;
2053 MpegEncContext best_s
, backup_s
;
2054 uint8_t bit_buf
[2][MAX_MB_BYTES
];
2055 uint8_t bit_buf2
[2][MAX_MB_BYTES
];
2056 uint8_t bit_buf_tex
[2][MAX_MB_BYTES
];
2057 PutBitContext pb
[2], pb2
[2], tex_pb
[2];
2058 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2060 ff_check_alignment();
2063 init_put_bits(&pb
[i
], bit_buf
[i
], MAX_MB_BYTES
);
2064 init_put_bits(&pb2
[i
], bit_buf2
[i
], MAX_MB_BYTES
);
2065 init_put_bits(&tex_pb
[i
], bit_buf_tex
[i
], MAX_MB_BYTES
);
2068 s
->last_bits
= put_bits_count(&s
->pb
);
2079 /* init last dc values */
2080 /* note: quant matrix value (8) is implied here */
2081 s
->last_dc
[i
] = 128 << s
->intra_dc_precision
;
2083 s
->current_picture
.error
[i
] = 0;
2086 memset(s
->last_mv
, 0, sizeof(s
->last_mv
));
2090 switch(s
->codec_id
){
2092 case CODEC_ID_H263P
:
2094 if (CONFIG_H263_ENCODER
)
2095 s
->gob_index
= ff_h263_get_gob_height(s
);
2097 case CODEC_ID_MPEG4
:
2098 if(CONFIG_MPEG4_ENCODER
&& s
->partitioned_frame
)
2099 ff_mpeg4_init_partitions(s
);
2105 s
->first_slice_line
= 1;
2106 s
->ptr_lastgob
= s
->pb
.buf
;
2107 for(mb_y
= s
->start_mb_y
; mb_y
< s
->end_mb_y
; mb_y
++) {
2108 // printf("row %d at %X\n", s->mb_y, (int)s);
2112 ff_set_qscale(s
, s
->qscale
);
2113 ff_init_block_index(s
);
2115 for(mb_x
=0; mb_x
< s
->mb_width
; mb_x
++) {
2116 int xy
= mb_y
*s
->mb_stride
+ mb_x
; // removed const, H261 needs to adjust this
2117 int mb_type
= s
->mb_type
[xy
];
2122 if(s
->pb
.buf_end
- s
->pb
.buf
- (put_bits_count(&s
->pb
)>>3) < MAX_MB_BYTES
){
2123 av_log(s
->avctx
, AV_LOG_ERROR
, "encoded frame too large\n");
2126 if(s
->data_partitioning
){
2127 if( s
->pb2
.buf_end
- s
->pb2
.buf
- (put_bits_count(&s
-> pb2
)>>3) < MAX_MB_BYTES
2128 || s
->tex_pb
.buf_end
- s
->tex_pb
.buf
- (put_bits_count(&s
->tex_pb
)>>3) < MAX_MB_BYTES
){
2129 av_log(s
->avctx
, AV_LOG_ERROR
, "encoded frame too large\n");
2135 s
->mb_y
= mb_y
; // moved into loop, can get changed by H.261
2136 ff_update_block_index(s
);
2138 if(CONFIG_H261_ENCODER
&& s
->codec_id
== CODEC_ID_H261
){
2139 ff_h261_reorder_mb_index(s
);
2140 xy
= s
->mb_y
*s
->mb_stride
+ s
->mb_x
;
2141 mb_type
= s
->mb_type
[xy
];
2144 /* write gob / video packet header */
2146 int current_packet_size
, is_gob_start
;
2148 current_packet_size
= ((put_bits_count(&s
->pb
)+7)>>3) - (s
->ptr_lastgob
- s
->pb
.buf
);
2150 is_gob_start
= s
->avctx
->rtp_payload_size
&& current_packet_size
>= s
->avctx
->rtp_payload_size
&& mb_y
+ mb_x
>0;
2152 if(s
->start_mb_y
== mb_y
&& mb_y
> 0 && mb_x
==0) is_gob_start
=1;
2154 switch(s
->codec_id
){
2156 case CODEC_ID_H263P
:
2157 if(!s
->h263_slice_structured
)
2158 if(s
->mb_x
|| s
->mb_y
%s
->gob_index
) is_gob_start
=0;
2160 case CODEC_ID_MPEG2VIDEO
:
2161 if(s
->mb_x
==0 && s
->mb_y
!=0) is_gob_start
=1;
2162 case CODEC_ID_MPEG1VIDEO
:
2163 if(s
->mb_skip_run
) is_gob_start
=0;
2168 if(s
->start_mb_y
!= mb_y
|| mb_x
!=0){
2171 if(CONFIG_MPEG4_ENCODER
&& s
->codec_id
==CODEC_ID_MPEG4
&& s
->partitioned_frame
){
2172 ff_mpeg4_init_partitions(s
);
2176 assert((put_bits_count(&s
->pb
)&7) == 0);
2177 current_packet_size
= put_bits_ptr(&s
->pb
) - s
->ptr_lastgob
;
2179 if(s
->avctx
->error_rate
&& s
->resync_mb_x
+ s
->resync_mb_y
> 0){
2180 int r
= put_bits_count(&s
->pb
)/8 + s
->picture_number
+ 16 + s
->mb_x
+ s
->mb_y
;
2181 int d
= 100 / s
->avctx
->error_rate
;
2183 current_packet_size
=0;
2184 #ifndef ALT_BITSTREAM_WRITER
2185 s
->pb
.buf_ptr
= s
->ptr_lastgob
;
2187 assert(put_bits_ptr(&s
->pb
) == s
->ptr_lastgob
);
2191 if (s
->avctx
->rtp_callback
){
2192 int number_mb
= (mb_y
- s
->resync_mb_y
)*s
->mb_width
+ mb_x
- s
->resync_mb_x
;
2193 s
->avctx
->rtp_callback(s
->avctx
, s
->ptr_lastgob
, current_packet_size
, number_mb
);
2196 switch(s
->codec_id
){
2197 case CODEC_ID_MPEG4
:
2198 if (CONFIG_MPEG4_ENCODER
) {
2199 ff_mpeg4_encode_video_packet_header(s
);
2200 ff_mpeg4_clean_buffers(s
);
2203 case CODEC_ID_MPEG1VIDEO
:
2204 case CODEC_ID_MPEG2VIDEO
:
2205 if (CONFIG_MPEG1VIDEO_ENCODER
|| CONFIG_MPEG2VIDEO_ENCODER
) {
2206 ff_mpeg1_encode_slice_header(s
);
2207 ff_mpeg1_clean_buffers(s
);
2211 case CODEC_ID_H263P
:
2212 if (CONFIG_H263_ENCODER
)
2213 h263_encode_gob_header(s
, mb_y
);
2217 if(s
->flags
&CODEC_FLAG_PASS1
){
2218 int bits
= put_bits_count(&s
->pb
);
2219 s
->misc_bits
+= bits
- s
->last_bits
;
2223 s
->ptr_lastgob
+= current_packet_size
;
2224 s
->first_slice_line
=1;
2225 s
->resync_mb_x
=mb_x
;
2226 s
->resync_mb_y
=mb_y
;
2230 if( (s
->resync_mb_x
== s
->mb_x
)
2231 && s
->resync_mb_y
+1 == s
->mb_y
){
2232 s
->first_slice_line
=0;
2236 s
->dquant
=0; //only for QP_RD
2238 if(mb_type
& (mb_type
-1) || (s
->flags
& CODEC_FLAG_QP_RD
)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
2240 int pb_bits_count
, pb2_bits_count
, tex_pb_bits_count
;
2242 copy_context_before_encode(&backup_s
, s
, -1);
2244 best_s
.data_partitioning
= s
->data_partitioning
;
2245 best_s
.partitioned_frame
= s
->partitioned_frame
;
2246 if(s
->data_partitioning
){
2247 backup_s
.pb2
= s
->pb2
;
2248 backup_s
.tex_pb
= s
->tex_pb
;
2251 if(mb_type
&CANDIDATE_MB_TYPE_INTER
){
2252 s
->mv_dir
= MV_DIR_FORWARD
;
2253 s
->mv_type
= MV_TYPE_16X16
;
2255 s
->mv
[0][0][0] = s
->p_mv_table
[xy
][0];
2256 s
->mv
[0][0][1] = s
->p_mv_table
[xy
][1];
2257 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER
, pb
, pb2
, tex_pb
,
2258 &dmin
, &next_block
, s
->mv
[0][0][0], s
->mv
[0][0][1]);
2260 if(mb_type
&CANDIDATE_MB_TYPE_INTER_I
){
2261 s
->mv_dir
= MV_DIR_FORWARD
;
2262 s
->mv_type
= MV_TYPE_FIELD
;
2265 j
= s
->field_select
[0][i
] = s
->p_field_select_table
[i
][xy
];
2266 s
->mv
[0][i
][0] = s
->p_field_mv_table
[i
][j
][xy
][0];
2267 s
->mv
[0][i
][1] = s
->p_field_mv_table
[i
][j
][xy
][1];
2269 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER_I
, pb
, pb2
, tex_pb
,
2270 &dmin
, &next_block
, 0, 0);
2272 if(mb_type
&CANDIDATE_MB_TYPE_SKIPPED
){
2273 s
->mv_dir
= MV_DIR_FORWARD
;
2274 s
->mv_type
= MV_TYPE_16X16
;
2278 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_SKIPPED
, pb
, pb2
, tex_pb
,
2279 &dmin
, &next_block
, s
->mv
[0][0][0], s
->mv
[0][0][1]);
2281 if(mb_type
&CANDIDATE_MB_TYPE_INTER4V
){
2282 s
->mv_dir
= MV_DIR_FORWARD
;
2283 s
->mv_type
= MV_TYPE_8X8
;
2286 s
->mv
[0][i
][0] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][0];
2287 s
->mv
[0][i
][1] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][1];
2289 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER4V
, pb
, pb2
, tex_pb
,
2290 &dmin
, &next_block
, 0, 0);
2292 if(mb_type
&CANDIDATE_MB_TYPE_FORWARD
){
2293 s
->mv_dir
= MV_DIR_FORWARD
;
2294 s
->mv_type
= MV_TYPE_16X16
;
2296 s
->mv
[0][0][0] = s
->b_forw_mv_table
[xy
][0];
2297 s
->mv
[0][0][1] = s
->b_forw_mv_table
[xy
][1];
2298 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_FORWARD
, pb
, pb2
, tex_pb
,
2299 &dmin
, &next_block
, s
->mv
[0][0][0], s
->mv
[0][0][1]);
2301 if(mb_type
&CANDIDATE_MB_TYPE_BACKWARD
){
2302 s
->mv_dir
= MV_DIR_BACKWARD
;
2303 s
->mv_type
= MV_TYPE_16X16
;
2305 s
->mv
[1][0][0] = s
->b_back_mv_table
[xy
][0];
2306 s
->mv
[1][0][1] = s
->b_back_mv_table
[xy
][1];
2307 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BACKWARD
, pb
, pb2
, tex_pb
,
2308 &dmin
, &next_block
, s
->mv
[1][0][0], s
->mv
[1][0][1]);
2310 if(mb_type
&CANDIDATE_MB_TYPE_BIDIR
){
2311 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2312 s
->mv_type
= MV_TYPE_16X16
;
2314 s
->mv
[0][0][0] = s
->b_bidir_forw_mv_table
[xy
][0];
2315 s
->mv
[0][0][1] = s
->b_bidir_forw_mv_table
[xy
][1];
2316 s
->mv
[1][0][0] = s
->b_bidir_back_mv_table
[xy
][0];
2317 s
->mv
[1][0][1] = s
->b_bidir_back_mv_table
[xy
][1];
2318 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BIDIR
, pb
, pb2
, tex_pb
,
2319 &dmin
, &next_block
, 0, 0);
2321 if(mb_type
&CANDIDATE_MB_TYPE_FORWARD_I
){
2322 s
->mv_dir
= MV_DIR_FORWARD
;
2323 s
->mv_type
= MV_TYPE_FIELD
;
2326 j
= s
->field_select
[0][i
] = s
->b_field_select_table
[0][i
][xy
];
2327 s
->mv
[0][i
][0] = s
->b_field_mv_table
[0][i
][j
][xy
][0];
2328 s
->mv
[0][i
][1] = s
->b_field_mv_table
[0][i
][j
][xy
][1];
2330 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_FORWARD_I
, pb
, pb2
, tex_pb
,
2331 &dmin
, &next_block
, 0, 0);
2333 if(mb_type
&CANDIDATE_MB_TYPE_BACKWARD_I
){
2334 s
->mv_dir
= MV_DIR_BACKWARD
;
2335 s
->mv_type
= MV_TYPE_FIELD
;
2338 j
= s
->field_select
[1][i
] = s
->b_field_select_table
[1][i
][xy
];
2339 s
->mv
[1][i
][0] = s
->b_field_mv_table
[1][i
][j
][xy
][0];
2340 s
->mv
[1][i
][1] = s
->b_field_mv_table
[1][i
][j
][xy
][1];
2342 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BACKWARD_I
, pb
, pb2
, tex_pb
,
2343 &dmin
, &next_block
, 0, 0);
2345 if(mb_type
&CANDIDATE_MB_TYPE_BIDIR_I
){
2346 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2347 s
->mv_type
= MV_TYPE_FIELD
;
2349 for(dir
=0; dir
<2; dir
++){
2351 j
= s
->field_select
[dir
][i
] = s
->b_field_select_table
[dir
][i
][xy
];
2352 s
->mv
[dir
][i
][0] = s
->b_field_mv_table
[dir
][i
][j
][xy
][0];
2353 s
->mv
[dir
][i
][1] = s
->b_field_mv_table
[dir
][i
][j
][xy
][1];
2356 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_BIDIR_I
, pb
, pb2
, tex_pb
,
2357 &dmin
, &next_block
, 0, 0);
2359 if(mb_type
&CANDIDATE_MB_TYPE_INTRA
){
2361 s
->mv_type
= MV_TYPE_16X16
;
2365 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTRA
, pb
, pb2
, tex_pb
,
2366 &dmin
, &next_block
, 0, 0);
2367 if(s
->h263_pred
|| s
->h263_aic
){
2369 s
->mbintra_table
[mb_x
+ mb_y
*s
->mb_stride
]=1;
2371 ff_clean_intra_table_entries(s
); //old mode?
2375 if((s
->flags
& CODEC_FLAG_QP_RD
) && dmin
< INT_MAX
){
2376 if(best_s
.mv_type
==MV_TYPE_16X16
){ //FIXME move 4mv after QPRD
2377 const int last_qp
= backup_s
.qscale
;
2380 const int mvdir
= (best_s
.mv_dir
&MV_DIR_BACKWARD
) ?
1 : 0;
2381 static const int dquant_tab
[4]={-1,1,-2,2};
2383 assert(backup_s
.dquant
== 0);
2386 s
->mv_dir
= best_s
.mv_dir
;
2387 s
->mv_type
= MV_TYPE_16X16
;
2388 s
->mb_intra
= best_s
.mb_intra
;
2389 s
->mv
[0][0][0] = best_s
.mv
[0][0][0];
2390 s
->mv
[0][0][1] = best_s
.mv
[0][0][1];
2391 s
->mv
[1][0][0] = best_s
.mv
[1][0][0];
2392 s
->mv
[1][0][1] = best_s
.mv
[1][0][1];
2394 qpi
= s
->pict_type
== FF_B_TYPE ?
2 : 0;
2395 for(; qpi
<4; qpi
++){
2396 int dquant
= dquant_tab
[qpi
];
2397 qp
= last_qp
+ dquant
;
2398 if(qp
< s
->avctx
->qmin
|| qp
> s
->avctx
->qmax
)
2400 backup_s
.dquant
= dquant
;
2401 if(s
->mb_intra
&& s
->dc_val
[0]){
2403 dc
[i
]= s
->dc_val
[0][ s
->block_index
[i
] ];
2404 memcpy(ac
[i
], s
->ac_val
[0][s
->block_index
[i
]], sizeof(DCTELEM
)*16);
2408 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER
/* wrong but unused */, pb
, pb2
, tex_pb
,
2409 &dmin
, &next_block
, s
->mv
[mvdir
][0][0], s
->mv
[mvdir
][0][1]);
2410 if(best_s
.qscale
!= qp
){
2411 if(s
->mb_intra
&& s
->dc_val
[0]){
2413 s
->dc_val
[0][ s
->block_index
[i
] ]= dc
[i
];
2414 memcpy(s
->ac_val
[0][s
->block_index
[i
]], ac
[i
], sizeof(DCTELEM
)*16);
2421 if(CONFIG_MPEG4_ENCODER
&& mb_type
&CANDIDATE_MB_TYPE_DIRECT
){
2422 int mx
= s
->b_direct_mv_table
[xy
][0];
2423 int my
= s
->b_direct_mv_table
[xy
][1];
2425 backup_s
.dquant
= 0;
2426 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
| MV_DIRECT
;
2428 ff_mpeg4_set_direct_mv(s
, mx
, my
);
2429 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_DIRECT
, pb
, pb2
, tex_pb
,
2430 &dmin
, &next_block
, mx
, my
);
2432 if(CONFIG_MPEG4_ENCODER
&& mb_type
&CANDIDATE_MB_TYPE_DIRECT0
){
2433 backup_s
.dquant
= 0;
2434 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
| MV_DIRECT
;
2436 ff_mpeg4_set_direct_mv(s
, 0, 0);
2437 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_DIRECT
, pb
, pb2
, tex_pb
,
2438 &dmin
, &next_block
, 0, 0);
2440 if(!best_s
.mb_intra
&& s
->flags2
&CODEC_FLAG2_SKIP_RD
){
2443 coded
|= s
->block_last_index
[i
];
2446 memcpy(s
->mv
, best_s
.mv
, sizeof(s
->mv
));
2447 if(CONFIG_MPEG4_ENCODER
&& best_s
.mv_dir
& MV_DIRECT
){
2448 mx
=my
=0; //FIXME find the one we actually used
2449 ff_mpeg4_set_direct_mv(s
, mx
, my
);
2450 }else if(best_s
.mv_dir
&MV_DIR_BACKWARD
){
2458 s
->mv_dir
= best_s
.mv_dir
;
2459 s
->mv_type
= best_s
.mv_type
;
2461 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2462 s->mv[0][0][1] = best_s.mv[0][0][1];
2463 s->mv[1][0][0] = best_s.mv[1][0][0];
2464 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2467 encode_mb_hq(s
, &backup_s
, &best_s
, CANDIDATE_MB_TYPE_INTER
/* wrong but unused */, pb
, pb2
, tex_pb
,
2468 &dmin
, &next_block
, mx
, my
);
2473 s
->current_picture
.qscale_table
[xy
]= best_s
.qscale
;
2475 copy_context_after_encode(s
, &best_s
, -1);
2477 pb_bits_count
= put_bits_count(&s
->pb
);
2478 flush_put_bits(&s
->pb
);
2479 ff_copy_bits(&backup_s
.pb
, bit_buf
[next_block
^1], pb_bits_count
);
2482 if(s
->data_partitioning
){
2483 pb2_bits_count
= put_bits_count(&s
->pb2
);
2484 flush_put_bits(&s
->pb2
);
2485 ff_copy_bits(&backup_s
.pb2
, bit_buf2
[next_block
^1], pb2_bits_count
);
2486 s
->pb2
= backup_s
.pb2
;
2488 tex_pb_bits_count
= put_bits_count(&s
->tex_pb
);
2489 flush_put_bits(&s
->tex_pb
);
2490 ff_copy_bits(&backup_s
.tex_pb
, bit_buf_tex
[next_block
^1], tex_pb_bits_count
);
2491 s
->tex_pb
= backup_s
.tex_pb
;
2493 s
->last_bits
= put_bits_count(&s
->pb
);
2495 if (CONFIG_H263_ENCODER
&&
2496 s
->out_format
== FMT_H263
&& s
->pict_type
!=FF_B_TYPE
)
2497 ff_h263_update_motion_val(s
);
2499 if(next_block
==0){ //FIXME 16 vs linesize16
2500 s
->dsp
.put_pixels_tab
[0][0](s
->dest
[0], s
->rd_scratchpad
, s
->linesize
,16);
2501 s
->dsp
.put_pixels_tab
[1][0](s
->dest
[1], s
->rd_scratchpad
+ 16*s
->linesize
, s
->uvlinesize
, 8);
2502 s
->dsp
.put_pixels_tab
[1][0](s
->dest
[2], s
->rd_scratchpad
+ 16*s
->linesize
+ 8, s
->uvlinesize
, 8);
2505 if(s
->avctx
->mb_decision
== FF_MB_DECISION_BITS
)
2506 MPV_decode_mb(s
, s
->block
);
2508 int motion_x
= 0, motion_y
= 0;
2509 s
->mv_type
=MV_TYPE_16X16
;
2510 // only one MB-Type possible
2513 case CANDIDATE_MB_TYPE_INTRA
:
2516 motion_x
= s
->mv
[0][0][0] = 0;
2517 motion_y
= s
->mv
[0][0][1] = 0;
2519 case CANDIDATE_MB_TYPE_INTER
:
2520 s
->mv_dir
= MV_DIR_FORWARD
;
2522 motion_x
= s
->mv
[0][0][0] = s
->p_mv_table
[xy
][0];
2523 motion_y
= s
->mv
[0][0][1] = s
->p_mv_table
[xy
][1];
2525 case CANDIDATE_MB_TYPE_INTER_I
:
2526 s
->mv_dir
= MV_DIR_FORWARD
;
2527 s
->mv_type
= MV_TYPE_FIELD
;
2530 j
= s
->field_select
[0][i
] = s
->p_field_select_table
[i
][xy
];
2531 s
->mv
[0][i
][0] = s
->p_field_mv_table
[i
][j
][xy
][0];
2532 s
->mv
[0][i
][1] = s
->p_field_mv_table
[i
][j
][xy
][1];
2535 case CANDIDATE_MB_TYPE_INTER4V
:
2536 s
->mv_dir
= MV_DIR_FORWARD
;
2537 s
->mv_type
= MV_TYPE_8X8
;
2540 s
->mv
[0][i
][0] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][0];
2541 s
->mv
[0][i
][1] = s
->current_picture
.motion_val
[0][s
->block_index
[i
]][1];
2544 case CANDIDATE_MB_TYPE_DIRECT
:
2545 if (CONFIG_MPEG4_ENCODER
) {
2546 s
->mv_dir
= MV_DIR_FORWARD
|MV_DIR_BACKWARD
|MV_DIRECT
;
2548 motion_x
=s
->b_direct_mv_table
[xy
][0];
2549 motion_y
=s
->b_direct_mv_table
[xy
][1];
2550 ff_mpeg4_set_direct_mv(s
, motion_x
, motion_y
);
2553 case CANDIDATE_MB_TYPE_DIRECT0
:
2554 if (CONFIG_MPEG4_ENCODER
) {
2555 s
->mv_dir
= MV_DIR_FORWARD
|MV_DIR_BACKWARD
|MV_DIRECT
;
2557 ff_mpeg4_set_direct_mv(s
, 0, 0);
2560 case CANDIDATE_MB_TYPE_BIDIR
:
2561 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2563 s
->mv
[0][0][0] = s
->b_bidir_forw_mv_table
[xy
][0];
2564 s
->mv
[0][0][1] = s
->b_bidir_forw_mv_table
[xy
][1];
2565 s
->mv
[1][0][0] = s
->b_bidir_back_mv_table
[xy
][0];
2566 s
->mv
[1][0][1] = s
->b_bidir_back_mv_table
[xy
][1];
2568 case CANDIDATE_MB_TYPE_BACKWARD
:
2569 s
->mv_dir
= MV_DIR_BACKWARD
;
2571 motion_x
= s
->mv
[1][0][0] = s
->b_back_mv_table
[xy
][0];
2572 motion_y
= s
->mv
[1][0][1] = s
->b_back_mv_table
[xy
][1];
2574 case CANDIDATE_MB_TYPE_FORWARD
:
2575 s
->mv_dir
= MV_DIR_FORWARD
;
2577 motion_x
= s
->mv
[0][0][0] = s
->b_forw_mv_table
[xy
][0];
2578 motion_y
= s
->mv
[0][0][1] = s
->b_forw_mv_table
[xy
][1];
2579 // printf(" %d %d ", motion_x, motion_y);
2581 case CANDIDATE_MB_TYPE_FORWARD_I
:
2582 s
->mv_dir
= MV_DIR_FORWARD
;
2583 s
->mv_type
= MV_TYPE_FIELD
;
2586 j
= s
->field_select
[0][i
] = s
->b_field_select_table
[0][i
][xy
];
2587 s
->mv
[0][i
][0] = s
->b_field_mv_table
[0][i
][j
][xy
][0];
2588 s
->mv
[0][i
][1] = s
->b_field_mv_table
[0][i
][j
][xy
][1];
2591 case CANDIDATE_MB_TYPE_BACKWARD_I
:
2592 s
->mv_dir
= MV_DIR_BACKWARD
;
2593 s
->mv_type
= MV_TYPE_FIELD
;
2596 j
= s
->field_select
[1][i
] = s
->b_field_select_table
[1][i
][xy
];
2597 s
->mv
[1][i
][0] = s
->b_field_mv_table
[1][i
][j
][xy
][0];
2598 s
->mv
[1][i
][1] = s
->b_field_mv_table
[1][i
][j
][xy
][1];
2601 case CANDIDATE_MB_TYPE_BIDIR_I
:
2602 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
;
2603 s
->mv_type
= MV_TYPE_FIELD
;
2605 for(dir
=0; dir
<2; dir
++){
2607 j
= s
->field_select
[dir
][i
] = s
->b_field_select_table
[dir
][i
][xy
];
2608 s
->mv
[dir
][i
][0] = s
->b_field_mv_table
[dir
][i
][j
][xy
][0];
2609 s
->mv
[dir
][i
][1] = s
->b_field_mv_table
[dir
][i
][j
][xy
][1];
2614 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal MB type\n");
2617 encode_mb(s
, motion_x
, motion_y
);
2619 // RAL: Update last macroblock type
2620 s
->last_mv_dir
= s
->mv_dir
;
2622 if (CONFIG_H263_ENCODER
&&
2623 s
->out_format
== FMT_H263
&& s
->pict_type
!=FF_B_TYPE
)
2624 ff_h263_update_motion_val(s
);
2626 MPV_decode_mb(s
, s
->block
);
2629 /* clean the MV table in IPS frames for direct mode in B frames */
2630 if(s
->mb_intra
/* && I,P,S_TYPE */){
2631 s
->p_mv_table
[xy
][0]=0;
2632 s
->p_mv_table
[xy
][1]=0;
2635 if(s
->flags
&CODEC_FLAG_PSNR
){
2639 if(s
->mb_x
*16 + 16 > s
->width
) w
= s
->width
- s
->mb_x
*16;
2640 if(s
->mb_y
*16 + 16 > s
->height
) h
= s
->height
- s
->mb_y
*16;
2642 s
->current_picture
.error
[0] += sse(
2643 s
, s
->new_picture
.data
[0] + s
->mb_x
*16 + s
->mb_y
*s
->linesize
*16,
2644 s
->dest
[0], w
, h
, s
->linesize
);
2645 s
->current_picture
.error
[1] += sse(
2646 s
, s
->new_picture
.data
[1] + s
->mb_x
*8 + s
->mb_y
*s
->uvlinesize
*chr_h
,
2647 s
->dest
[1], w
>>1, h
>>s
->chroma_y_shift
, s
->uvlinesize
);
2648 s
->current_picture
.error
[2] += sse(
2649 s
, s
->new_picture
.data
[2] + s
->mb_x
*8 + s
->mb_y
*s
->uvlinesize
*chr_h
,
2650 s
->dest
[2], w
>>1, h
>>s
->chroma_y_shift
, s
->uvlinesize
);
2653 if(CONFIG_H263_ENCODER
&& s
->out_format
== FMT_H263
)
2654 ff_h263_loop_filter(s
);
2656 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
2660 //not beautiful here but we must write it before flushing so it has to be here
2661 if (CONFIG_MSMPEG4_ENCODER
&& s
->msmpeg4_version
&& s
->msmpeg4_version
<4 && s
->pict_type
== FF_I_TYPE
)
2662 msmpeg4_encode_ext_header(s
);
2666 /* Send the last GOB if RTP */
2667 if (s
->avctx
->rtp_callback
) {
2668 int number_mb
= (mb_y
- s
->resync_mb_y
)*s
->mb_width
- s
->resync_mb_x
;
2669 pdif
= put_bits_ptr(&s
->pb
) - s
->ptr_lastgob
;
2670 /* Call the RTP callback to send the last GOB */
2672 s
->avctx
->rtp_callback(s
->avctx
, s
->ptr_lastgob
, pdif
, number_mb
);
2678 #define MERGE(field) dst->field += src->field; src->field=0
2679 static void merge_context_after_me(MpegEncContext
*dst
, MpegEncContext
*src
){
2680 MERGE(me
.scene_change_score
);
2681 MERGE(me
.mc_mb_var_sum_temp
);
2682 MERGE(me
.mb_var_sum_temp
);
2685 static void merge_context_after_encode(MpegEncContext
*dst
, MpegEncContext
*src
){
2688 MERGE(dct_count
[0]); //note, the other dct vars are not part of the context
2689 MERGE(dct_count
[1]);
2699 MERGE(padding_bug_score
);
2700 MERGE(current_picture
.error
[0]);
2701 MERGE(current_picture
.error
[1]);
2702 MERGE(current_picture
.error
[2]);
2704 if(dst
->avctx
->noise_reduction
){
2705 for(i
=0; i
<64; i
++){
2706 MERGE(dct_error_sum
[0][i
]);
2707 MERGE(dct_error_sum
[1][i
]);
2711 assert(put_bits_count(&src
->pb
) % 8 ==0);
2712 assert(put_bits_count(&dst
->pb
) % 8 ==0);
2713 ff_copy_bits(&dst
->pb
, src
->pb
.buf
, put_bits_count(&src
->pb
));
2714 flush_put_bits(&dst
->pb
);
2717 static int estimate_qp(MpegEncContext
*s
, int dry_run
){
2718 if (s
->next_lambda
){
2719 s
->current_picture_ptr
->quality
=
2720 s
->current_picture
.quality
= s
->next_lambda
;
2721 if(!dry_run
) s
->next_lambda
= 0;
2722 } else if (!s
->fixed_qscale
) {
2723 s
->current_picture_ptr
->quality
=
2724 s
->current_picture
.quality
= ff_rate_estimate_qscale(s
, dry_run
);