Revision 2f349de2 libavcodec/mpegvideo.c
| libavcodec/mpegvideo.c | ||
|---|---|---|
| 35 | 35 |
DCTELEM *block, int n, int qscale); |
| 36 | 36 |
static void dct_unquantize_h263_c(MpegEncContext *s, |
| 37 | 37 |
DCTELEM *block, int n, int qscale); |
| 38 |
static int dct_quantize(MpegEncContext *s, DCTELEM *block, int n, int qscale); |
|
| 39 |
static int dct_quantize_mmx(MpegEncContext *s, |
|
| 40 |
DCTELEM *block, int n, |
|
| 41 |
int qscale); |
|
| 42 | 38 |
static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w); |
| 39 |
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale); |
|
| 43 | 40 |
|
| 41 |
int (*dct_quantize)(MpegEncContext *s, DCTELEM *block, int n, int qscale)= dct_quantize_c; |
|
| 44 | 42 |
void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c; |
| 45 | 43 |
|
| 46 | 44 |
#define EDGE_WIDTH 16 |
| ... | ... | |
| 74 | 72 |
|
| 75 | 73 |
extern UINT8 zigzag_end[64]; |
| 76 | 74 |
|
| 77 |
/* XXX: should use variable shift ? */ |
|
| 78 |
#define QMAT_SHIFT_MMX 19 |
|
| 79 |
#define QMAT_SHIFT 25 |
|
| 80 |
|
|
| 81 |
static void convert_matrix(int *qmat, const UINT16 *quant_matrix, int qscale) |
|
| 75 |
static void convert_matrix(int *qmat, UINT16 *qmat16, const UINT16 *quant_matrix, int qscale) |
|
| 82 | 76 |
{
|
| 83 | 77 |
int i; |
| 84 | 78 |
|
| 85 | 79 |
if (av_fdct == jpeg_fdct_ifast) {
|
| 86 | 80 |
for(i=0;i<64;i++) {
|
| 87 | 81 |
/* 16 <= qscale * quant_matrix[i] <= 7905 */ |
| 88 |
/* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
|
| 82 |
/* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
|
| 83 |
/* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ |
|
| 84 |
/* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
|
| 89 | 85 |
|
| 90 |
qmat[i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 11)) /
|
|
| 91 |
(aanscales[i] * qscale * quant_matrix[i]));
|
|
| 86 |
qmat[block_permute_op(i)] = (int)((UINT64_C(1) << (QMAT_SHIFT + 11)) /
|
|
| 87 |
(aanscales[i] * qscale * quant_matrix[block_permute_op(i)]));
|
|
| 92 | 88 |
} |
| 93 | 89 |
} else {
|
| 94 | 90 |
for(i=0;i<64;i++) {
|
| 95 | 91 |
/* We can safely suppose that 16 <= quant_matrix[i] <= 255 |
| 96 |
So 16 <= qscale * quant_matrix[i] <= 7905 |
|
| 97 |
so (1 << QMAT_SHIFT) / 16 >= qmat[i] >= (1 << QMAT_SHIFT) / 7905 |
|
| 92 |
So 16 <= qscale * quant_matrix[i] <= 7905 |
|
| 93 |
so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 |
|
| 94 |
so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 |
|
| 98 | 95 |
*/ |
| 99 |
qmat[i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); |
|
| 96 |
qmat[i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); |
|
| 97 |
qmat16[i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[block_permute_op(i)]); |
|
| 100 | 98 |
} |
| 101 | 99 |
} |
| 102 | 100 |
} |
| ... | ... | |
| 418 | 416 |
void MPV_frame_end(MpegEncContext *s) |
| 419 | 417 |
{
|
| 420 | 418 |
/* draw edge for correct motion prediction if outside */ |
| 421 |
if (s->pict_type != B_TYPE) {
|
|
| 419 |
if (s->pict_type != B_TYPE && !s->intra_only) {
|
|
| 422 | 420 |
if(s->avctx==NULL || s->avctx->codec->id!=CODEC_ID_MPEG4){
|
| 423 | 421 |
draw_edges(s->current_picture[0], s->linesize, s->mb_width*16, s->mb_height*16, EDGE_WIDTH); |
| 424 | 422 |
draw_edges(s->current_picture[1], s->linesize/2, s->mb_width*8, s->mb_height*8, EDGE_WIDTH/2); |
| ... | ... | |
| 457 | 455 |
avctx->key_frame = (s->pict_type == I_TYPE); |
| 458 | 456 |
|
| 459 | 457 |
MPV_frame_start(s); |
| 460 |
|
|
| 458 |
|
|
| 461 | 459 |
for(i=0;i<3;i++) {
|
| 462 | 460 |
UINT8 *src = pict->data[i]; |
| 463 | 461 |
UINT8 *dest = s->current_picture[i]; |
| ... | ... | |
| 472 | 470 |
h >>= 1; |
| 473 | 471 |
} |
| 474 | 472 |
|
| 475 |
for(j=0;j<h;j++) {
|
|
| 476 |
memcpy(dest, src, w); |
|
| 477 |
dest += dest_wrap; |
|
| 478 |
src += src_wrap; |
|
| 479 |
} |
|
| 473 |
if(s->intra_only && dest_wrap==src_wrap){
|
|
| 474 |
s->current_picture[i] = pict->data[i]; |
|
| 475 |
}else {
|
|
| 476 |
for(j=0;j<h;j++) {
|
|
| 477 |
memcpy(dest, src, w); |
|
| 478 |
dest += dest_wrap; |
|
| 479 |
src += src_wrap; |
|
| 480 |
} |
|
| 481 |
} |
|
| 480 | 482 |
s->new_picture[i] = s->current_picture[i]; |
| 481 | 483 |
} |
| 482 | 484 |
|
| ... | ... | |
| 873 | 875 |
s->intra_matrix[0] = default_intra_matrix[0]; |
| 874 | 876 |
for(i=1;i<64;i++) |
| 875 | 877 |
s->intra_matrix[i] = (default_intra_matrix[i] * s->qscale) >> 3; |
| 876 |
convert_matrix(s->q_intra_matrix, s->intra_matrix, 8); |
|
| 878 |
convert_matrix(s->q_intra_matrix, s->q_intra_matrix16, s->intra_matrix, 8);
|
|
| 877 | 879 |
} else {
|
| 878 |
convert_matrix(s->q_intra_matrix, s->intra_matrix, s->qscale); |
|
| 879 |
convert_matrix(s->q_non_intra_matrix, s->non_intra_matrix, s->qscale); |
|
| 880 |
convert_matrix(s->q_intra_matrix, s->q_intra_matrix16, s->intra_matrix, s->qscale);
|
|
| 881 |
convert_matrix(s->q_non_intra_matrix, s->q_non_intra_matrix16, s->non_intra_matrix, s->qscale);
|
|
| 880 | 882 |
} |
| 881 | 883 |
|
| 882 | 884 |
switch(s->out_format) {
|
| ... | ... | |
| 1011 | 1013 |
s->y_dc_scale = 8; |
| 1012 | 1014 |
s->c_dc_scale = 8; |
| 1013 | 1015 |
} |
| 1014 |
|
|
| 1015 | 1016 |
for(i=0;i<6;i++) {
|
| 1016 |
int last_index; |
|
| 1017 |
if (av_fdct == jpeg_fdct_ifast) |
|
| 1018 |
last_index = dct_quantize(s, s->block[i], i, s->qscale); |
|
| 1019 |
else |
|
| 1020 |
last_index = dct_quantize_mmx(s, s->block[i], i, s->qscale); |
|
| 1021 |
s->block_last_index[i] = last_index; |
|
| 1017 |
s->block_last_index[i] = dct_quantize(s, s->block[i], i, s->qscale); |
|
| 1022 | 1018 |
} |
| 1023 | 1019 |
|
| 1024 | 1020 |
/* huffman encode */ |
| ... | ... | |
| 1060 | 1056 |
// fprintf(stderr,"\nNumber of GOB: %d", s->gob_number); |
| 1061 | 1057 |
} |
| 1062 | 1058 |
|
| 1063 |
static int dct_quantize(MpegEncContext *s, |
|
| 1059 |
static int dct_quantize_c(MpegEncContext *s,
|
|
| 1064 | 1060 |
DCTELEM *block, int n, |
| 1065 | 1061 |
int qscale) |
| 1066 | 1062 |
{
|
| ... | ... | |
| 1157 | 1153 |
level = maxLevel; |
| 1158 | 1154 |
else if (level < minLevel) |
| 1159 | 1155 |
level = minLevel; |
| 1160 |
block[j] = level; |
|
| 1161 |
last_non_zero = i; |
|
| 1162 |
} else {
|
|
| 1163 |
block[j] = 0; |
|
| 1164 |
} |
|
| 1165 |
} |
|
| 1166 |
return last_non_zero; |
|
| 1167 |
} |
|
| 1168 |
|
|
| 1169 |
static int dct_quantize_mmx(MpegEncContext *s, |
|
| 1170 |
DCTELEM *block, int n, |
|
| 1171 |
int qscale) |
|
| 1172 |
{
|
|
| 1173 |
int i, j, level, last_non_zero, q; |
|
| 1174 |
const int *qmat; |
|
| 1175 |
int minLevel, maxLevel; |
|
| 1176 |
|
|
| 1177 |
if(s->avctx!=NULL && s->avctx->codec->id==CODEC_ID_MPEG4){
|
|
| 1178 |
/* mpeg4 */ |
|
| 1179 |
minLevel= -2048; |
|
| 1180 |
maxLevel= 2047; |
|
| 1181 |
}else if(s->out_format==FMT_MPEG1){
|
|
| 1182 |
/* mpeg1 */ |
|
| 1183 |
minLevel= -255; |
|
| 1184 |
maxLevel= 255; |
|
| 1185 |
}else{
|
|
| 1186 |
/* h263 / msmpeg4 */ |
|
| 1187 |
minLevel= -128; |
|
| 1188 |
maxLevel= 127; |
|
| 1189 |
} |
|
| 1190 | 1156 |
|
| 1191 |
av_fdct (block); |
|
| 1192 |
|
|
| 1193 |
/* we need this permutation so that we correct the IDCT |
|
| 1194 |
permutation. will be moved into DCT code */ |
|
| 1195 |
block_permute(block); |
|
| 1196 |
|
|
| 1197 |
if (s->mb_intra) {
|
|
| 1198 |
if (n < 4) |
|
| 1199 |
q = s->y_dc_scale; |
|
| 1200 |
else |
|
| 1201 |
q = s->c_dc_scale; |
|
| 1202 |
|
|
| 1203 |
/* note: block[0] is assumed to be positive */ |
|
| 1204 |
block[0] = (block[0] + (q >> 1)) / q; |
|
| 1205 |
i = 1; |
|
| 1206 |
last_non_zero = 0; |
|
| 1207 |
if (s->out_format == FMT_H263) {
|
|
| 1208 |
qmat = s->q_non_intra_matrix; |
|
| 1209 |
} else {
|
|
| 1210 |
qmat = s->q_intra_matrix; |
|
| 1211 |
} |
|
| 1212 |
} else {
|
|
| 1213 |
i = 0; |
|
| 1214 |
last_non_zero = -1; |
|
| 1215 |
qmat = s->q_non_intra_matrix; |
|
| 1216 |
} |
|
| 1217 |
|
|
| 1218 |
for(;i<64;i++) {
|
|
| 1219 |
j = zigzag_direct[i]; |
|
| 1220 |
level = block[j]; |
|
| 1221 |
level = level * qmat[j]; |
|
| 1222 |
/* XXX: slight error for the low range. Test should be equivalent to |
|
| 1223 |
(level <= -(1 << (QMAT_SHIFT_MMX - 3)) || level >= (1 << |
|
| 1224 |
(QMAT_SHIFT_MMX - 3))) |
|
| 1225 |
*/ |
|
| 1226 |
if (((level << (31 - (QMAT_SHIFT_MMX - 3))) >> (31 - (QMAT_SHIFT_MMX - 3))) != |
|
| 1227 |
level) {
|
|
| 1228 |
level = level / (1 << (QMAT_SHIFT_MMX - 3)); |
|
| 1229 |
/* XXX: currently, this code is not optimal. the range should be: |
|
| 1230 |
mpeg1: -255..255 |
|
| 1231 |
mpeg2: -2048..2047 |
|
| 1232 |
h263: -128..127 |
|
| 1233 |
mpeg4: -2048..2047 |
|
| 1234 |
*/ |
|
| 1235 |
if (level > maxLevel) |
|
| 1236 |
level = maxLevel; |
|
| 1237 |
else if (level < minLevel) |
|
| 1238 |
level = minLevel; |
|
| 1239 | 1157 |
block[j] = level; |
| 1240 | 1158 |
last_non_zero = i; |
| 1241 | 1159 |
} else {
|
Also available in: Unified diff