← Back to branch summary

~ubuntu-branches/ubuntu/karmic/mplayer/karmic

« back to all changes in this revision

Viewing changes to libavcodec/h264idct.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2009-06-06 23:01:52 UTC
  • mfrom: (0.1.6 squeeze) (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090606230152-qxn13xfnq65nz088
Tags: 2:1.0~rc3+svn20090426-1ubuntu1
https://launchpad.net/bugs/336697
https://launchpad.net/bugs/260918
https://launchpad.net/bugs/246675
https://launchpad.net/bugs/243453
https://launchpad.net/bugs/74282
https://launchpad.net/bugs/308939
https://launchpad.net/bugs/73271
https://launchpad.net/bugs/347021
* Switch to debian packaging for the mplayer package
* New upstream release, LP: #336697, #260918, #246675, #243453, #74282
* Fixes security issues: CVE-2008-5616, LP: #308939
* many flv fixes LP: #73271, #347021
* Build and install mencoder
* Bump epoch

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/h264idct.c
20
20
 */
21
21
 
22
22
/**
23
 
 * @file h264-idct.c
 
23
 * @file libavcodec/h264idct.c
24
24
 * H.264 IDCT.
25
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
26
 */
72
72
 
73
73
void ff_h264_idct8_add_c(uint8_t *dst, DCTELEM *block, int stride){
74
74
    int i;
75
 
    DCTELEM (*src)[8] = (DCTELEM(*)[8])block;
76
75
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
77
76
 
78
77
    block[0] += 32;
79
78
 
80
79
    for( i = 0; i < 8; i++ )
81
80
    {
82
 
        const int a0 =  src[i][0] + src[i][4];
83
 
        const int a2 =  src[i][0] - src[i][4];
84
 
        const int a4 = (src[i][2]>>1) - src[i][6];
85
 
        const int a6 = (src[i][6]>>1) + src[i][2];
 
81
        const int a0 =  block[0+i*8] + block[4+i*8];
 
82
        const int a2 =  block[0+i*8] - block[4+i*8];
 
83
        const int a4 = (block[2+i*8]>>1) - block[6+i*8];
 
84
        const int a6 = (block[6+i*8]>>1) + block[2+i*8];
86
85
 
87
86
        const int b0 = a0 + a6;
88
87
        const int b2 = a2 + a4;
89
88
        const int b4 = a2 - a4;
90
89
        const int b6 = a0 - a6;
91
90
 
92
 
        const int a1 = -src[i][3] + src[i][5] - src[i][7] - (src[i][7]>>1);
93
 
        const int a3 =  src[i][1] + src[i][7] - src[i][3] - (src[i][3]>>1);
94
 
        const int a5 = -src[i][1] + src[i][7] + src[i][5] + (src[i][5]>>1);
95
 
        const int a7 =  src[i][3] + src[i][5] + src[i][1] + (src[i][1]>>1);
 
91
        const int a1 = -block[3+i*8] + block[5+i*8] - block[7+i*8] - (block[7+i*8]>>1);
 
92
        const int a3 =  block[1+i*8] + block[7+i*8] - block[3+i*8] - (block[3+i*8]>>1);
 
93
        const int a5 = -block[1+i*8] + block[7+i*8] + block[5+i*8] + (block[5+i*8]>>1);
 
94
        const int a7 =  block[3+i*8] + block[5+i*8] + block[1+i*8] + (block[1+i*8]>>1);
96
95
 
97
96
        const int b1 = (a7>>2) + a1;
98
97
        const int b3 =  a3 + (a5>>2);
99
98
        const int b5 = (a3>>2) - a5;
100
99
        const int b7 =  a7 - (a1>>2);
101
100
 
102
 
        src[i][0] = b0 + b7;
103
 
        src[i][7] = b0 - b7;
104
 
        src[i][1] = b2 + b5;
105
 
        src[i][6] = b2 - b5;
106
 
        src[i][2] = b4 + b3;
107
 
        src[i][5] = b4 - b3;
108
 
        src[i][3] = b6 + b1;
109
 
        src[i][4] = b6 - b1;
 
101
        block[0+i*8] = b0 + b7;
 
102
        block[7+i*8] = b0 - b7;
 
103
        block[1+i*8] = b2 + b5;
 
104
        block[6+i*8] = b2 - b5;
 
105
        block[2+i*8] = b4 + b3;
 
106
        block[5+i*8] = b4 - b3;
 
107
        block[3+i*8] = b6 + b1;
 
108
        block[4+i*8] = b6 - b1;
110
109
    }
111
110
    for( i = 0; i < 8; i++ )
112
111
    {
113
 
        const int a0 =  src[0][i] + src[4][i];
114
 
        const int a2 =  src[0][i] - src[4][i];
115
 
        const int a4 = (src[2][i]>>1) - src[6][i];
116
 
        const int a6 = (src[6][i]>>1) + src[2][i];
 
112
        const int a0 =  block[i+0*8] + block[i+4*8];
 
113
        const int a2 =  block[i+0*8] - block[i+4*8];
 
114
        const int a4 = (block[i+2*8]>>1) - block[i+6*8];
 
115
        const int a6 = (block[i+6*8]>>1) + block[i+2*8];
117
116
 
118
117
        const int b0 = a0 + a6;
119
118
        const int b2 = a2 + a4;
120
119
        const int b4 = a2 - a4;
121
120
        const int b6 = a0 - a6;
122
121
 
123
 
        const int a1 = -src[3][i] + src[5][i] - src[7][i] - (src[7][i]>>1);
124
 
        const int a3 =  src[1][i] + src[7][i] - src[3][i] - (src[3][i]>>1);
125
 
        const int a5 = -src[1][i] + src[7][i] + src[5][i] + (src[5][i]>>1);
126
 
        const int a7 =  src[3][i] + src[5][i] + src[1][i] + (src[1][i]>>1);
 
122
        const int a1 = -block[i+3*8] + block[i+5*8] - block[i+7*8] - (block[i+7*8]>>1);
 
123
        const int a3 =  block[i+1*8] + block[i+7*8] - block[i+3*8] - (block[i+3*8]>>1);
 
124
        const int a5 = -block[i+1*8] + block[i+7*8] + block[i+5*8] + (block[i+5*8]>>1);
 
125
        const int a7 =  block[i+3*8] + block[i+5*8] + block[i+1*8] + (block[i+1*8]>>1);
127
126
 
128
127
        const int b1 = (a7>>2) + a1;
129
128
        const int b3 =  a3 + (a5>>2);
165
164
        dst += stride;
166
165
    }
167
166
}
 
167
 
 
168
//FIXME this table is a duplicate from h264data.h, and will be removed once the tables from, h264 have been split
 
169
static const uint8_t scan8[16 + 2*4]={
 
170
 4+1*8, 5+1*8, 4+2*8, 5+2*8,
 
171
 6+1*8, 7+1*8, 6+2*8, 7+2*8,
 
172
 4+3*8, 5+3*8, 4+4*8, 5+4*8,
 
173
 6+3*8, 7+3*8, 6+4*8, 7+4*8,
 
174
 1+1*8, 2+1*8,
 
175
 1+2*8, 2+2*8,
 
176
 1+4*8, 2+4*8,
 
177
 1+5*8, 2+5*8,
 
178
};
 
179
 
 
180
void ff_h264_idct_add16_c(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
 
181
    int i;
 
182
    for(i=0; i<16; i++){
 
183
        int nnz = nnzc[ scan8[i] ];
 
184
        if(nnz){
 
185
            if(nnz==1 && block[i*16]) ff_h264_idct_dc_add_c(dst + block_offset[i], block + i*16, stride);
 
186
            else                      idct_internal        (dst + block_offset[i], block + i*16, stride, 4, 6, 1);
 
187
        }
 
188
    }
 
189
}
 
190
 
 
191
void ff_h264_idct_add16intra_c(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
 
192
    int i;
 
193
    for(i=0; i<16; i++){
 
194
        if(nnzc[ scan8[i] ]) idct_internal        (dst + block_offset[i], block + i*16, stride, 4, 6, 1);
 
195
        else if(block[i*16]) ff_h264_idct_dc_add_c(dst + block_offset[i], block + i*16, stride);
 
196
    }
 
197
}
 
198
 
 
199
void ff_h264_idct8_add4_c(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
 
200
    int i;
 
201
    for(i=0; i<16; i+=4){
 
202
        int nnz = nnzc[ scan8[i] ];
 
203
        if(nnz){
 
204
            if(nnz==1 && block[i*16]) ff_h264_idct8_dc_add_c(dst + block_offset[i], block + i*16, stride);
 
205
            else                      ff_h264_idct8_add_c   (dst + block_offset[i], block + i*16, stride);
 
206
        }
 
207
    }
 
208
}
 
209
 
 
210
void ff_h264_idct_add8_c(uint8_t **dest, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
 
211
    int i;
 
212
    for(i=16; i<16+8; i++){
 
213
        if(nnzc[ scan8[i] ])
 
214
            ff_h264_idct_add_c   (dest[(i&4)>>2] + block_offset[i], block + i*16, stride);
 
215
        else if(block[i*16])
 
216
            ff_h264_idct_dc_add_c(dest[(i&4)>>2] + block_offset[i], block + i*16, stride);
 
217
    }
 
218
}