Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dsputil.c @ badaf88e

History | View | Annotate | Download (20.8 KB)

1
/*
2
 * DSP utils
3
 * Copyright (c) 2000, 2001 Gerard Lantau.
4
 *
5
 * This program is free software; you can redistribute it and/or modify
6
 * it under the terms of the GNU General Public License as published by
7
 * the Free Software Foundation; either version 2 of the License, or
8
 * (at your option) any later version.
9
 *
10
 * This program is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 * GNU General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU General Public License
16
 * along with this program; if not, write to the Free Software
17
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
 */
19
#include <stdlib.h>
20
#include <stdio.h>
21
#include "avcodec.h"
22
#include "dsputil.h"
23
#include "simple_idct.h"
24

    
25
void (*ff_idct)(DCTELEM *block);
26
void (*get_pixels)(DCTELEM *block, const UINT8 *pixels, int line_size);
27
void (*put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
28
void (*add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
29

    
30
op_pixels_abs_func pix_abs16x16;
31
op_pixels_abs_func pix_abs16x16_x2;
32
op_pixels_abs_func pix_abs16x16_y2;
33
op_pixels_abs_func pix_abs16x16_xy2;
34

    
35
UINT8 cropTbl[256 + 2 * MAX_NEG_CROP];
36
UINT32 squareTbl[512];
37

    
38
extern UINT16 default_intra_matrix[64];
39
extern UINT16 default_non_intra_matrix[64];
40

    
41
UINT8 zigzag_direct[64] = {
42
    0, 1, 8, 16, 9, 2, 3, 10,
43
    17, 24, 32, 25, 18, 11, 4, 5,
44
    12, 19, 26, 33, 40, 48, 41, 34,
45
    27, 20, 13, 6, 7, 14, 21, 28,
46
    35, 42, 49, 56, 57, 50, 43, 36,
47
    29, 22, 15, 23, 30, 37, 44, 51,
48
    58, 59, 52, 45, 38, 31, 39, 46,
49
    53, 60, 61, 54, 47, 55, 62, 63
50
};
51

    
52
UINT8 ff_alternate_horizontal_scan[64] = {
53
    0,  1,  2,  3,  8,  9, 16, 17, 
54
    10, 11,  4,  5,  6,  7, 15, 14,
55
    13, 12, 19, 18, 24, 25, 32, 33, 
56
    26, 27, 20, 21, 22, 23, 28, 29,
57
    30, 31, 34, 35, 40, 41, 48, 49, 
58
    42, 43, 36, 37, 38, 39, 44, 45,
59
    46, 47, 50, 51, 56, 57, 58, 59, 
60
    52, 53, 54, 55, 60, 61, 62, 63,
61
};
62

    
63
UINT8 ff_alternate_vertical_scan[64] = {
64
    0,  8, 16, 24,  1,  9,  2, 10, 
65
    17, 25, 32, 40, 48, 56, 57, 49,
66
    41, 33, 26, 18,  3, 11,  4, 12, 
67
    19, 27, 34, 42, 50, 58, 35, 43,
68
    51, 59, 20, 28,  5, 13,  6, 14, 
69
    21, 29, 36, 44, 52, 60, 37, 45,
70
    53, 61, 22, 30,  7, 15, 23, 31, 
71
    38, 46, 54, 62, 39, 47, 55, 63,
72
};
73

    
74

    
75
static UINT8 simple_mmx_permutation[64]={
76
        0x00, 0x08, 0x01, 0x09, 0x04, 0x0C, 0x05, 0x0D,
77
        0x10, 0x18, 0x11, 0x19, 0x14, 0x1C, 0x15, 0x1D,
78
        0x02, 0x0A, 0x03, 0x0B, 0x06, 0x0E, 0x07, 0x0F,
79
        0x12, 0x1A, 0x13, 0x1B, 0x16, 0x1E, 0x17, 0x1F,
80
        0x20, 0x28, 0x21, 0x29, 0x24, 0x2C, 0x25, 0x2D,
81
        0x30, 0x38, 0x31, 0x39, 0x34, 0x3C, 0x35, 0x3D,
82
        0x22, 0x2A, 0x23, 0x2B, 0x26, 0x2E, 0x27, 0x2F,
83
        0x32, 0x3A, 0x33, 0x3B, 0x36, 0x3E, 0x37, 0x3F,
84
};
85

    
86
/* used to skip zeros at the end */
87
UINT8 zigzag_end[64];
88

    
89
UINT8 permutation[64];
90
//UINT8 invPermutation[64];
91

    
92
static void build_zigzag_end()
93
{
94
    int lastIndex;
95
    int lastIndexAfterPerm=0;
96
    for(lastIndex=0; lastIndex<64; lastIndex++)
97
    {
98
        if(zigzag_direct[lastIndex] > lastIndexAfterPerm) 
99
            lastIndexAfterPerm= zigzag_direct[lastIndex];
100
        zigzag_end[lastIndex]= lastIndexAfterPerm + 1;
101
    }
102
}
103

    
104
void get_pixels_c(DCTELEM *block, const UINT8 *pixels, int line_size)
105
{
106
    DCTELEM *p;
107
    const UINT8 *pix;
108
    int i;
109

    
110
    /* read the pixels */
111
    p = block;
112
    pix = pixels;
113
    for(i=0;i<8;i++) {
114
        p[0] = pix[0];
115
        p[1] = pix[1];
116
        p[2] = pix[2];
117
        p[3] = pix[3];
118
        p[4] = pix[4];
119
        p[5] = pix[5];
120
        p[6] = pix[6];
121
        p[7] = pix[7];
122
        pix += line_size;
123
        p += 8;
124
    }
125
}
126

    
127
void put_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size)
128
{
129
    const DCTELEM *p;
130
    UINT8 *pix;
131
    int i;
132
    UINT8 *cm = cropTbl + MAX_NEG_CROP;
133
    
134
    /* read the pixels */
135
    p = block;
136
    pix = pixels;
137
    for(i=0;i<8;i++) {
138
        pix[0] = cm[p[0]];
139
        pix[1] = cm[p[1]];
140
        pix[2] = cm[p[2]];
141
        pix[3] = cm[p[3]];
142
        pix[4] = cm[p[4]];
143
        pix[5] = cm[p[5]];
144
        pix[6] = cm[p[6]];
145
        pix[7] = cm[p[7]];
146
        pix += line_size;
147
        p += 8;
148
    }
149
}
150

    
151
void add_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size)
152
{
153
    const DCTELEM *p;
154
    UINT8 *pix;
155
    int i;
156
    UINT8 *cm = cropTbl + MAX_NEG_CROP;
157
    
158
    /* read the pixels */
159
    p = block;
160
    pix = pixels;
161
    for(i=0;i<8;i++) {
162
        pix[0] = cm[pix[0] + p[0]];
163
        pix[1] = cm[pix[1] + p[1]];
164
        pix[2] = cm[pix[2] + p[2]];
165
        pix[3] = cm[pix[3] + p[3]];
166
        pix[4] = cm[pix[4] + p[4]];
167
        pix[5] = cm[pix[5] + p[5]];
168
        pix[6] = cm[pix[6] + p[6]];
169
        pix[7] = cm[pix[7] + p[7]];
170
        pix += line_size;
171
        p += 8;
172
    }
173
}
174

    
175
#define PIXOP(BTYPE, OPNAME, OP, INCR)                                                   \
176
                                                                                         \
177
static void OPNAME ## _pixels(BTYPE *block, const UINT8 *pixels, int line_size, int h)    \
178
{                                                                                        \
179
    BTYPE *p;                                                                            \
180
    const UINT8 *pix;                                                                    \
181
                                                                                         \
182
    p = block;                                                                           \
183
    pix = pixels;                                                                        \
184
    do {                                                                                 \
185
        OP(p[0], pix[0]);                                                                  \
186
        OP(p[1], pix[1]);                                                                  \
187
        OP(p[2], pix[2]);                                                                  \
188
        OP(p[3], pix[3]);                                                                  \
189
        OP(p[4], pix[4]);                                                                  \
190
        OP(p[5], pix[5]);                                                                  \
191
        OP(p[6], pix[6]);                                                                  \
192
        OP(p[7], pix[7]);                                                                  \
193
        pix += line_size;                                                                \
194
        p += INCR;                                                                       \
195
    } while (--h);;                                                                       \
196
}                                                                                        \
197
                                                                                         \
198
static void OPNAME ## _pixels_x2(BTYPE *block, const UINT8 *pixels, int line_size, int h)     \
199
{                                                                                        \
200
    BTYPE *p;                                                                          \
201
    const UINT8 *pix;                                                                    \
202
                                                                                         \
203
    p = block;                                                                           \
204
    pix = pixels;                                                                        \
205
    do {                                                                   \
206
        OP(p[0], avg2(pix[0], pix[1]));                                                    \
207
        OP(p[1], avg2(pix[1], pix[2]));                                                    \
208
        OP(p[2], avg2(pix[2], pix[3]));                                                    \
209
        OP(p[3], avg2(pix[3], pix[4]));                                                    \
210
        OP(p[4], avg2(pix[4], pix[5]));                                                    \
211
        OP(p[5], avg2(pix[5], pix[6]));                                                    \
212
        OP(p[6], avg2(pix[6], pix[7]));                                                    \
213
        OP(p[7], avg2(pix[7], pix[8]));                                                    \
214
        pix += line_size;                                                                \
215
        p += INCR;                                                                       \
216
    } while (--h);                                                                        \
217
}                                                                                        \
218
                                                                                         \
219
static void OPNAME ## _pixels_y2(BTYPE *block, const UINT8 *pixels, int line_size, int h)     \
220
{                                                                                        \
221
    BTYPE *p;                                                                          \
222
    const UINT8 *pix;                                                                    \
223
    const UINT8 *pix1;                                                                   \
224
                                                                                         \
225
    p = block;                                                                           \
226
    pix = pixels;                                                                        \
227
    pix1 = pixels + line_size;                                                           \
228
    do {                                                                                 \
229
        OP(p[0], avg2(pix[0], pix1[0]));                                                   \
230
        OP(p[1], avg2(pix[1], pix1[1]));                                                   \
231
        OP(p[2], avg2(pix[2], pix1[2]));                                                   \
232
        OP(p[3], avg2(pix[3], pix1[3]));                                                   \
233
        OP(p[4], avg2(pix[4], pix1[4]));                                                   \
234
        OP(p[5], avg2(pix[5], pix1[5]));                                                   \
235
        OP(p[6], avg2(pix[6], pix1[6]));                                                   \
236
        OP(p[7], avg2(pix[7], pix1[7]));                                                   \
237
        pix += line_size;                                                                \
238
        pix1 += line_size;                                                               \
239
        p += INCR;                                                                       \
240
    } while(--h);                                                                         \
241
}                                                                                        \
242
                                                                                         \
243
static void OPNAME ## _pixels_xy2(BTYPE *block, const UINT8 *pixels, int line_size, int h)    \
244
{                                                                                        \
245
    BTYPE *p;                                                                          \
246
    const UINT8 *pix;                                                                    \
247
    const UINT8 *pix1;                                                                   \
248
                                                                                         \
249
    p = block;                                                                           \
250
    pix = pixels;                                                                        \
251
    pix1 = pixels + line_size;                                                           \
252
    do {                                                                   \
253
        OP(p[0], avg4(pix[0], pix[1], pix1[0], pix1[1]));                                  \
254
        OP(p[1], avg4(pix[1], pix[2], pix1[1], pix1[2]));                                  \
255
        OP(p[2], avg4(pix[2], pix[3], pix1[2], pix1[3]));                                  \
256
        OP(p[3], avg4(pix[3], pix[4], pix1[3], pix1[4]));                                  \
257
        OP(p[4], avg4(pix[4], pix[5], pix1[4], pix1[5]));                                  \
258
        OP(p[5], avg4(pix[5], pix[6], pix1[5], pix1[6]));                                  \
259
        OP(p[6], avg4(pix[6], pix[7], pix1[6], pix1[7]));                                  \
260
        OP(p[7], avg4(pix[7], pix[8], pix1[7], pix1[8]));                                  \
261
        pix += line_size;                                                                \
262
        pix1 += line_size;                                                               \
263
        p += INCR;                                                                       \
264
    } while(--h);                                                                         \
265
}                                                                                        \
266
                                                                                         \
267
void (*OPNAME ## _pixels_tab[4])(BTYPE *block, const UINT8 *pixels, int line_size, int h) = { \
268
    OPNAME ## _pixels,                                                                   \
269
    OPNAME ## _pixels_x2,                                                                \
270
    OPNAME ## _pixels_y2,                                                                \
271
    OPNAME ## _pixels_xy2,                                                               \
272
};
273

    
274

    
275
/* rounding primitives */
276
#define avg2(a,b) ((a+b+1)>>1)
277
#define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
278

    
279
#define op_put(a, b) a = b
280
#define op_avg(a, b) a = avg2(a, b)
281
#define op_sub(a, b) a -= b
282

    
283
PIXOP(UINT8, put, op_put, line_size)
284
PIXOP(UINT8, avg, op_avg, line_size)
285

    
286
PIXOP(DCTELEM, sub, op_sub, 8)
287

    
288
/* not rounding primitives */
289
#undef avg2
290
#undef avg4
291
#define avg2(a,b) ((a+b)>>1)
292
#define avg4(a,b,c,d) ((a+b+c+d+1)>>2)
293

    
294
PIXOP(UINT8, put_no_rnd, op_put, line_size)
295
PIXOP(UINT8, avg_no_rnd, op_avg, line_size)
296

    
297
/* motion estimation */
298

    
299
#undef avg2
300
#undef avg4
301
#define avg2(a,b) ((a+b+1)>>1)
302
#define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
303

    
304
int pix_abs16x16_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
305
{
306
    int s, i;
307

    
308
    s = 0;
309
    for(i=0;i<h;i++) {
310
        s += abs(pix1[0] - pix2[0]);
311
        s += abs(pix1[1] - pix2[1]);
312
        s += abs(pix1[2] - pix2[2]);
313
        s += abs(pix1[3] - pix2[3]);
314
        s += abs(pix1[4] - pix2[4]);
315
        s += abs(pix1[5] - pix2[5]);
316
        s += abs(pix1[6] - pix2[6]);
317
        s += abs(pix1[7] - pix2[7]);
318
        s += abs(pix1[8] - pix2[8]);
319
        s += abs(pix1[9] - pix2[9]);
320
        s += abs(pix1[10] - pix2[10]);
321
        s += abs(pix1[11] - pix2[11]);
322
        s += abs(pix1[12] - pix2[12]);
323
        s += abs(pix1[13] - pix2[13]);
324
        s += abs(pix1[14] - pix2[14]);
325
        s += abs(pix1[15] - pix2[15]);
326
        pix1 += line_size;
327
        pix2 += line_size;
328
    }
329
    return s;
330
}
331

    
332
int pix_abs16x16_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
333
{
334
    int s, i;
335

    
336
    s = 0;
337
    for(i=0;i<h;i++) {
338
        s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
339
        s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
340
        s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
341
        s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
342
        s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
343
        s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
344
        s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
345
        s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
346
        s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
347
        s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
348
        s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
349
        s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
350
        s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
351
        s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
352
        s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
353
        s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
354
        pix1 += line_size;
355
        pix2 += line_size;
356
    }
357
    return s;
358
}
359

    
360
int pix_abs16x16_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
361
{
362
    int s, i;
363
    UINT8 *pix3 = pix2 + line_size;
364

    
365
    s = 0;
366
    for(i=0;i<h;i++) {
367
        s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
368
        s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
369
        s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
370
        s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
371
        s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
372
        s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
373
        s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
374
        s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
375
        s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
376
        s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
377
        s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
378
        s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
379
        s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
380
        s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
381
        s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
382
        s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
383
        pix1 += line_size;
384
        pix2 += line_size;
385
        pix3 += line_size;
386
    }
387
    return s;
388
}
389

    
390
int pix_abs16x16_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
391
{
392
    int s, i;
393
    UINT8 *pix3 = pix2 + line_size;
394

    
395
    s = 0;
396
    for(i=0;i<h;i++) {
397
        s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
398
        s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
399
        s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
400
        s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
401
        s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
402
        s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
403
        s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
404
        s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
405
        s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
406
        s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
407
        s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
408
        s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
409
        s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
410
        s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
411
        s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
412
        s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
413
        pix1 += line_size;
414
        pix2 += line_size;
415
        pix3 += line_size;
416
    }
417
    return s;
418
}
419

    
420
/* permute block according so that it corresponds to the MMX idct
421
   order */
422
#ifdef SIMPLE_IDCT
423
 /* general permutation, but perhaps slightly slower */
424
void block_permute(INT16 *block)
425
{
426
        int i;
427
        INT16 temp[64];
428

    
429
        for(i=0; i<64; i++) temp[ block_permute_op(i) ] = block[i];
430

    
431
        for(i=0; i<64; i++) block[i] = temp[i];
432
}
433
#else
434

    
435
void block_permute(INT16 *block)
436
{
437
    int tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
438
    int i;
439

    
440
    for(i=0;i<8;i++) {
441
        tmp1 = block[1];
442
        tmp2 = block[2];
443
        tmp3 = block[3];
444
        tmp4 = block[4];
445
        tmp5 = block[5];
446
        tmp6 = block[6];
447
        block[1] = tmp2;
448
        block[2] = tmp4;
449
        block[3] = tmp6;
450
        block[4] = tmp1;
451
        block[5] = tmp3;
452
        block[6] = tmp5;
453
        block += 8;
454
    }
455
}
456
#endif
457

    
458
void dsputil_init(void)
459
{
460
    int i, j;
461
    int use_permuted_idct;
462

    
463
    for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i;
464
    for(i=0;i<MAX_NEG_CROP;i++) {
465
        cropTbl[i] = 0;
466
        cropTbl[i + MAX_NEG_CROP + 256] = 255;
467
    }
468

    
469
    for(i=0;i<512;i++) {
470
        squareTbl[i] = (i - 256) * (i - 256);
471
    }
472

    
473
#ifdef SIMPLE_IDCT
474
    ff_idct = simple_idct;
475
#else
476
    ff_idct = j_rev_dct;
477
#endif
478
    get_pixels = get_pixels_c;
479
    put_pixels_clamped = put_pixels_clamped_c;
480
    add_pixels_clamped = add_pixels_clamped_c;
481

    
482
    pix_abs16x16 = pix_abs16x16_c;
483
    pix_abs16x16_x2 = pix_abs16x16_x2_c;
484
    pix_abs16x16_y2 = pix_abs16x16_y2_c;
485
    pix_abs16x16_xy2 = pix_abs16x16_xy2_c;
486
    av_fdct = jpeg_fdct_ifast;
487

    
488
    use_permuted_idct = 1;
489

    
490
#ifdef HAVE_MMX
491
    dsputil_init_mmx();
492
#endif
493
#ifdef ARCH_ARMV4L
494
    dsputil_init_armv4l();
495
#endif
496
#ifdef HAVE_MLIB
497
    dsputil_init_mlib();
498
    use_permuted_idct = 0;
499
#endif
500

    
501
#ifdef SIMPLE_IDCT
502
    if(ff_idct == simple_idct) use_permuted_idct=0;
503
#endif
504

    
505
    if(use_permuted_idct)
506
#ifdef SIMPLE_IDCT
507
        for(i=0; i<64; i++) permutation[i]= simple_mmx_permutation[i];
508
#else
509
        for(i=0; i<64; i++) permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
510
#endif
511
    else
512
        for(i=0; i<64; i++) permutation[i]=i;
513

    
514
    if (use_permuted_idct) {
515
        /* permute for IDCT */
516
        for(i=0;i<64;i++) {
517
            j = zigzag_direct[i];
518
            zigzag_direct[i] = block_permute_op(j);
519
            j = ff_alternate_horizontal_scan[i];
520
            ff_alternate_horizontal_scan[i] = block_permute_op(j);
521
            j = ff_alternate_vertical_scan[i];
522
            ff_alternate_vertical_scan[i] = block_permute_op(j);
523
        }
524
        block_permute(default_intra_matrix);
525
        block_permute(default_non_intra_matrix);
526
    }
527
    
528
    build_zigzag_end();
529
}