Revision 2f349de2 libavcodec/mpegvideo.c

View differences:

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