for (qscale = qmin; qscale <= qmax; qscale++) {
int i;
+ int qscale2;
+
+ if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
+ else qscale2 = qscale << 1;
+
if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
#if CONFIG_FAANDCT
fdsp->fdct == ff_faandct ||
fdsp->fdct == ff_jpeg_fdct_islow_10) {
for (i = 0; i < 64; i++) {
const int j = s->idsp.idct_permutation[i];
- int64_t den = (int64_t) qscale * quant_matrix[j];
+ int64_t den = (int64_t) qscale2 * quant_matrix[j];
/* 16 <= qscale * quant_matrix[i] <= 7905
* Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
* 19952 <= x <= 249205026
* (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
* 3444240 >= (1 << 36) / (x) >= 275 */
- qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
+ qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
}
} else if (fdsp->fdct == ff_fdct_ifast) {
for (i = 0; i < 64; i++) {
const int j = s->idsp.idct_permutation[i];
- int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
+ int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
/* 16 <= qscale * quant_matrix[i] <= 7905
* Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
* 19952 <= x <= 249205026
* (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
* 3444240 >= (1 << 36) / (x) >= 275 */
- qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
+ qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
}
} else {
for (i = 0; i < 64; i++) {
const int j = s->idsp.idct_permutation[i];
- int64_t den = (int64_t) qscale * quant_matrix[j];
+ int64_t den = (int64_t) qscale2 * quant_matrix[j];
/* We can safely suppose that 16 <= quant_matrix[i] <= 255
* Assume x = qscale * quant_matrix[i]
* So 16 <= x <= 7905
* so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
* so 32768 >= (1 << 19) / (x) >= 67 */
- qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
+ qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
//qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
// (qscale * quant_matrix[i]);
- qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
+ qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
if (qmat16[qscale][0][i] == 0 ||
qmat16[qscale][0][i] == 128 * 256)
static inline void update_qscale(MpegEncContext *s)
{
- if (s->q_scale_type == 1) {
+ if (s->q_scale_type == 1 && 0) {
int i;
int bestdiff=INT_MAX;
int best = 1;
- static const uint8_t non_linear_qscale[] = {
- 1,2,3,4,5,6,7,8,9,10,11,12,14,16,18,20,24,26,28
- };
-
- for (i = 0 ; i<FF_ARRAY_ELEMS(non_linear_qscale); i++) {
- int diff = FFABS((non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 7)) - (int)s->lambda * 139);
- if (non_linear_qscale[i] < s->avctx->qmin ||
- (non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
+
+ for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
+ int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
+ if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
+ (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
continue;
if (diff < bestdiff) {
bestdiff = diff;
- best = non_linear_qscale[i];
+ best = i;
}
}
s->qscale = best;
avctx->bit_rate * av_q2d(avctx->time_base) >
avctx->bit_rate_tolerance) {
av_log(avctx, AV_LOG_WARNING,
- "bitrate tolerance %d too small for bitrate %d, overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
+ "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, (int64_t)avctx->bit_rate);
avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
}
#if FF_API_QUANT_BIAS
FF_DISABLE_DEPRECATION_WARNINGS
- if (s->intra_quant_bias == FF_DEFAULT_QUANT_BIAS &&
- avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
+ if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
s->intra_quant_bias = avctx->intra_quant_bias;
- if (s->inter_quant_bias == FF_DEFAULT_QUANT_BIAS &&
- avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
+ if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
s->inter_quant_bias = avctx->inter_quant_bias;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
FF_ENABLE_DEPRECATION_WARNINGS
#endif
+#if FF_API_ERROR_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
+ memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
+ sizeof(s->current_picture.encoding_error));
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
}
static void update_noise_reduction(MpegEncContext *s)
if (avctx->rc_buffer_size) {
RateControlContext *rcc = &s->rc_context;
int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
+ int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
+ int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
if (put_bits_count(&s->pb) > max_size &&
s->lambda < s->lmax) {
- s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
+ s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
(s->qscale + 1) / s->qscale);
if (s->adaptive_quant) {
int i;
for (i = 0; i < s->mb_height * s->mb_stride; i++)
s->lambda_table[i] =
- FFMAX(s->lambda_table[i] + 1,
+ FFMAX(s->lambda_table[i] + min_step,
s->lambda_table[i] * (s->qscale + 1) /
s->qscale);
}
ff_write_pass1_stats(s);
for (i = 0; i < 4; i++) {
- s->current_picture_ptr->f->error[i] =
- s->current_picture.f->error[i] =
- s->current_picture.error[i];
- avctx->error[i] += s->current_picture_ptr->f->error[i];
+ s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
+ avctx->error[i] += s->current_picture_ptr->encoding_error[i];
}
ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
- s->current_picture_ptr->f->error,
+ s->current_picture_ptr->encoding_error,
(s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
s->pict_type);
/* note: quant matrix value (8) is implied here */
s->last_dc[i] = 128 << s->intra_dc_precision;
- s->current_picture.error[i] = 0;
+ s->current_picture.encoding_error[i] = 0;
}
if(s->codec_id==AV_CODEC_ID_AMV){
s->last_dc[0] = 128*8/13;
if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
- s->current_picture.error[0] += sse(
+ s->current_picture.encoding_error[0] += sse(
s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
s->dest[0], w, h, s->linesize);
- s->current_picture.error[1] += sse(
+ s->current_picture.encoding_error[1] += sse(
s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
- s->current_picture.error[2] += sse(
+ s->current_picture.encoding_error[2] += sse(
s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
}
MERGE(misc_bits);
MERGE(er.error_count);
MERGE(padding_bug_score);
- MERGE(current_picture.error[0]);
- MERGE(current_picture.error[1]);
- MERGE(current_picture.error[2]);
+ MERGE(current_picture.encoding_error[0]);
+ MERGE(current_picture.encoding_error[1]);
+ MERGE(current_picture.encoding_error[2]);
if(dst->avctx->noise_reduction){
for(i=0; i<64; i++){
uint8_t * length;
uint8_t * last_length;
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
+ int mpeg2_qscale;
s->fdsp.fdct(block);
qmul= qscale*16;
qadd= ((qscale-1)|1)*8;
+ if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
+ else mpeg2_qscale = qscale << 1;
+
if (s->mb_intra) {
int q;
if (!s->h263_aic) {
}else{ //MPEG1
j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
if(s->mb_intra){
- unquant_coeff = (int)( alevel * qscale * matrix[j]) >> 3;
+ unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
unquant_coeff = (unquant_coeff - 1) | 1;
}else{
- unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) matrix[j])) >> 4;
+ unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
unquant_coeff = (unquant_coeff - 1) | 1;
}
unquant_coeff<<= 3;
if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
unquant_coeff= (alevel*qmul + qadd)>>3;
}else{ //MPEG1
- unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) matrix[0])) >> 4;
+ unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
unquant_coeff = (unquant_coeff - 1) | 1;
}
unquant_coeff = (unquant_coeff + 4) >> 3;