Revision 55fde95e

View differences:

libavcodec/cavs.c
293 293
    int x,y,ia;
294 294
    int ih = 0;
295 295
    int iv = 0;
296
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
296
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
297 297

  
298 298
    for(x=0; x<4; x++) {
299 299
        ih += (x+1)*(top[5+x]-top[3-x]);
libavcodec/cavsdsp.c
184 184
static void cavs_idct8_add_c(uint8_t *dst, DCTELEM *block, int stride) {
185 185
    int i;
186 186
    DCTELEM (*src)[8] = (DCTELEM(*)[8])block;
187
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
187
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
188 188

  
189 189
    src[0][0] += 8;
190 190

  
......
260 260
#define CAVS_SUBPIX(OPNAME, OP, NAME, A, B, C, D, E, F) \
261 261
static void OPNAME ## cavs_filt8_h_ ## NAME(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
262 262
    const int h=8;\
263
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
263
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
264 264
    int i;\
265 265
    for(i=0; i<h; i++)\
266 266
    {\
......
279 279
\
280 280
static void OPNAME ## cavs_filt8_v_  ## NAME(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
281 281
    const int w=8;\
282
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
282
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
283 283
    int i;\
284 284
    for(i=0; i<w; i++)\
285 285
    {\
......
333 333
    int16_t *tmp = temp;\
334 334
    const int h=8;\
335 335
    const int w=8;\
336
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
336
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
337 337
    int i;\
338 338
    src1 -= 2*srcStride;\
339 339
    for(i=0; i<h+5; i++)\
libavcodec/dsputil.c
40 40
/* vorbis.c */
41 41
void vorbis_inverse_coupling(float *mag, float *ang, int blocksize);
42 42

  
43
uint8_t cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
43
uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
44 44
uint32_t squareTbl[512] = {0, };
45 45

  
46 46
const uint8_t ff_zigzag_direct[64] = {
......
436 436
                                 int line_size)
437 437
{
438 438
    int i;
439
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
439
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
440 440

  
441 441
    /* read the pixels */
442 442
    for(i=0;i<8;i++) {
......
458 458
                                 int line_size)
459 459
{
460 460
    int i;
461
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
461
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
462 462

  
463 463
    /* read the pixels */
464 464
    for(i=0;i<4;i++) {
......
476 476
                                 int line_size)
477 477
{
478 478
    int i;
479
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
479
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
480 480

  
481 481
    /* read the pixels */
482 482
    for(i=0;i<2;i++) {
......
513 513
                          int line_size)
514 514
{
515 515
    int i;
516
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
516
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
517 517

  
518 518
    /* read the pixels */
519 519
    for(i=0;i<8;i++) {
......
534 534
                          int line_size)
535 535
{
536 536
    int i;
537
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
537
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
538 538

  
539 539
    /* read the pixels */
540 540
    for(i=0;i<4;i++) {
......
551 551
                          int line_size)
552 552
{
553 553
    int i;
554
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
554
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
555 555

  
556 556
    /* read the pixels */
557 557
    for(i=0;i<2;i++) {
......
1592 1592

  
1593 1593
#define QPEL_MC(r, OPNAME, RND, OP) \
1594 1594
static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1595
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1595
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1596 1596
    int i;\
1597 1597
    for(i=0; i<h; i++)\
1598 1598
    {\
......
1611 1611
\
1612 1612
static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1613 1613
    const int w=8;\
1614
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1614
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1615 1615
    int i;\
1616 1616
    for(i=0; i<w; i++)\
1617 1617
    {\
......
1638 1638
}\
1639 1639
\
1640 1640
static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1641
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1641
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1642 1642
    int i;\
1643 1643
    \
1644 1644
    for(i=0; i<h; i++)\
......
1665 1665
}\
1666 1666
\
1667 1667
static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1668
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1668
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1669 1669
    int i;\
1670 1670
    const int w=16;\
1671 1671
    for(i=0; i<w; i++)\
......
2091 2091
#define H264_LOWPASS(OPNAME, OP, OP2) \
2092 2092
static void OPNAME ## h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2093 2093
    const int h=2;\
2094
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2094
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2095 2095
    int i;\
2096 2096
    for(i=0; i<h; i++)\
2097 2097
    {\
......
2104 2104
\
2105 2105
static void OPNAME ## h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2106 2106
    const int w=2;\
2107
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2107
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2108 2108
    int i;\
2109 2109
    for(i=0; i<w; i++)\
2110 2110
    {\
......
2125 2125
static void OPNAME ## h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2126 2126
    const int h=2;\
2127 2127
    const int w=2;\
2128
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2128
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2129 2129
    int i;\
2130 2130
    src -= 2*srcStride;\
2131 2131
    for(i=0; i<h+5; i++)\
......
2153 2153
}\
2154 2154
static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2155 2155
    const int h=4;\
2156
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2156
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2157 2157
    int i;\
2158 2158
    for(i=0; i<h; i++)\
2159 2159
    {\
......
2168 2168
\
2169 2169
static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2170 2170
    const int w=4;\
2171
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2171
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2172 2172
    int i;\
2173 2173
    for(i=0; i<w; i++)\
2174 2174
    {\
......
2193 2193
static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2194 2194
    const int h=4;\
2195 2195
    const int w=4;\
2196
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2196
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2197 2197
    int i;\
2198 2198
    src -= 2*srcStride;\
2199 2199
    for(i=0; i<h+5; i++)\
......
2228 2228
\
2229 2229
static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2230 2230
    const int h=8;\
2231
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2231
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2232 2232
    int i;\
2233 2233
    for(i=0; i<h; i++)\
2234 2234
    {\
......
2247 2247
\
2248 2248
static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2249 2249
    const int w=8;\
2250
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2250
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2251 2251
    int i;\
2252 2252
    for(i=0; i<w; i++)\
2253 2253
    {\
......
2280 2280
static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2281 2281
    const int h=8;\
2282 2282
    const int w=8;\
2283
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
2283
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2284 2284
    int i;\
2285 2285
    src -= 2*srcStride;\
2286 2286
    for(i=0; i<h+5; i++)\
......
2582 2582
#undef H264_WEIGHT
2583 2583

  
2584 2584
static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
2585
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
2585
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2586 2586
    int i;
2587 2587

  
2588 2588
    for(i=0; i<h; i++){
......
2627 2627
#endif /* CONFIG_VC1_DECODER||CONFIG_WMV3_DECODER */
2628 2628

  
2629 2629
static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
2630
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
2630
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2631 2631
    int i;
2632 2632

  
2633 2633
    for(i=0; i<w; i++){
......
3847 3847

  
3848 3848
static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
3849 3849
{
3850
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
3850
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
3851 3851

  
3852 3852
    dest[0] = cm[(block[0] + 4)>>3];
3853 3853
}
3854 3854
static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
3855 3855
{
3856
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
3856
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
3857 3857

  
3858 3858
    dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
3859 3859
}
......
3865 3865
{
3866 3866
    int i;
3867 3867

  
3868
    for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i;
3868
    for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
3869 3869
    for(i=0;i<MAX_NEG_CROP;i++) {
3870
        cropTbl[i] = 0;
3871
        cropTbl[i + MAX_NEG_CROP + 256] = 255;
3870
        ff_cropTbl[i] = 0;
3871
        ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
3872 3872
    }
3873 3873

  
3874 3874
    for(i=0;i<512;i++) {
libavcodec/dsputil.h
75 75

  
76 76
/* temporary */
77 77
extern uint32_t squareTbl[512];
78
extern uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
78
extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP];
79 79

  
80 80
/* VP3 DSP functions */
81 81
void ff_vp3_idct_c(DCTELEM *block/* align 16*/);
libavcodec/dvbsubdec.c
344 344
    int i, r, g, b, a = 0;
345 345
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
346 346

  
347
    cm = cropTbl + MAX_NEG_CROP;
347
    cm = ff_cropTbl + MAX_NEG_CROP;
348 348

  
349 349
    memset(avctx->priv_data, 0, sizeof(DVBSubContext));
350 350

  
libavcodec/error_resilience.c
199 199
 */
200 200
static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
201 201
    int b_x, b_y;
202
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
202
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
203 203

  
204 204
    for(b_y=0; b_y<h; b_y++){
205 205
        for(b_x=0; b_x<w-1; b_x++){
......
259 259
 */
260 260
static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
261 261
    int b_x, b_y;
262
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
262
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
263 263

  
264 264
    for(b_y=0; b_y<h-1; b_y++){
265 265
        for(b_x=0; b_x<w; b_x++){
libavcodec/h264.c
2451 2451
static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){
2452 2452
  int i, j, k;
2453 2453
  int a;
2454
  uint8_t *cm = cropTbl + MAX_NEG_CROP;
2454
  uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2455 2455
  const uint8_t * const src0 = src+7-stride;
2456 2456
  const uint8_t *src1 = src+8*stride-1;
2457 2457
  const uint8_t *src2 = src1-2*stride;      // == src+6*stride-1;
......
2594 2594
static void pred8x8_plane_c(uint8_t *src, int stride){
2595 2595
  int j, k;
2596 2596
  int a;
2597
  uint8_t *cm = cropTbl + MAX_NEG_CROP;
2597
  uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2598 2598
  const uint8_t * const src0 = src+3-stride;
2599 2599
  const uint8_t *src1 = src+4*stride-1;
2600 2600
  const uint8_t *src2 = src1-2*stride;      // == src+2*stride-1;
libavcodec/h264idct.c
30 30

  
31 31
static always_inline void idct_internal(uint8_t *dst, DCTELEM *block, int stride, int block_stride, int shift, int add){
32 32
    int i;
33
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
33
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
34 34

  
35 35
    block[0] += 1<<(shift-1);
36 36

  
......
74 74
void ff_h264_idct8_add_c(uint8_t *dst, DCTELEM *block, int stride){
75 75
    int i;
76 76
    DCTELEM (*src)[8] = (DCTELEM(*)[8])block;
77
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
77
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
78 78

  
79 79
    block[0] += 32;
80 80

  
......
145 145
// assumes all AC coefs are 0
146 146
void ff_h264_idct_dc_add_c(uint8_t *dst, DCTELEM *block, int stride){
147 147
    int i, j;
148
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
148
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
149 149
    int dc = (block[0] + 32) >> 6;
150 150
    for( j = 0; j < 4; j++ )
151 151
    {
......
157 157

  
158 158
void ff_h264_idct8_dc_add_c(uint8_t *dst, DCTELEM *block, int stride){
159 159
    int i, j;
160
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
160
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
161 161
    int dc = (block[0] + 32) >> 6;
162 162
    for( j = 0; j < 8; j++ )
163 163
    {
libavcodec/imgconvert.c
1241 1241
static void img_convert_init(void)
1242 1242
{
1243 1243
    int i;
1244
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
1244
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1245 1245

  
1246 1246
    for(i = 0;i < 256; i++) {
1247 1247
        y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
......
2653 2653
                             int size)
2654 2654
{
2655 2655
#ifndef HAVE_MMX
2656
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
2656
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2657 2657
    int sum;
2658 2658

  
2659 2659
    for(;size > 0;size--) {
......
2696 2696
                             int size)
2697 2697
{
2698 2698
#ifndef HAVE_MMX
2699
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
2699
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2700 2700
    int sum;
2701 2701

  
2702 2702
    for(;size > 0;size--) {
libavcodec/imgconvert_template.h
29 29
    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
30 30
    uint8_t *d, *d1, *d2;
31 31
    int w, y, cb, cr, r_add, g_add, b_add, width2;
32
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
32
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
33 33
    unsigned int r, g, b;
34 34

  
35 35
    d = dst->data[0];
......
123 123
    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
124 124
    uint8_t *d, *d1, *d2;
125 125
    int w, y, cb, cr, r_add, g_add, b_add, width2;
126
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
126
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
127 127
    unsigned int r, g, b;
128 128

  
129 129
    d = dst->data[0];
......
539 539
    const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
540 540
    uint8_t *d, *d1;
541 541
    int w, y, cb, cr, r_add, g_add, b_add;
542
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
542
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
543 543
    unsigned int r, g, b;
544 544

  
545 545
    d = dst->data[0];
......
572 572
    const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
573 573
    uint8_t *d, *d1;
574 574
    int w, y, cb, cr, r_add, g_add, b_add;
575
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
575
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
576 576
    unsigned int r, g, b;
577 577

  
578 578
    d = dst->data[0];
libavcodec/mlib/dsputil_mlib.c
384 384
static void ff_idct_put_mlib(uint8_t *dest, int line_size, DCTELEM *data)
385 385
{
386 386
    int i;
387
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
387
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
388 388

  
389 389
    mlib_VideoIDCT8x8_S16_S16 (data, data);
390 390

  
libavcodec/sh4/dsputil_sh4.c
70 70
{
71 71
        idct_sh4(block);
72 72
        int i;
73
        uint8_t *cm = cropTbl + MAX_NEG_CROP;
73
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
74 74
        for(i=0;i<8;i++) {
75 75
                dest[0] = cm[block[0]];
76 76
                dest[1] = cm[block[1]];
......
88 88
{
89 89
        idct_sh4(block);
90 90
        int i;
91
        uint8_t *cm = cropTbl + MAX_NEG_CROP;
91
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
92 92
        for(i=0;i<8;i++) {
93 93
                dest[0] = cm[dest[0]+block[0]];
94 94
                dest[1] = cm[dest[1]+block[1]];
libavcodec/sh4/qpel.c
633 633

  
634 634
#define QPEL_MC(r, OPNAME, RND, OP) \
635 635
static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
636
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
636
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
637 637
    do {\
638 638
        uint8_t *s = src; \
639 639
        int src0,src1,src2,src3,src4,src5,src6,src7,src8;\
......
660 660
}\
661 661
\
662 662
static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
663
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
663
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
664 664
    int w=8;\
665 665
    do{\
666 666
        uint8_t *s = src, *d=dst;\
......
688 688
}\
689 689
\
690 690
static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
691
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
691
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
692 692
    do {\
693 693
        uint8_t *s = src;\
694 694
        int src0,src1,src2,src3,src4,src5,src6,src7,src8;\
......
732 732
}\
733 733
\
734 734
static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
735
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
735
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
736 736
    int w=16;\
737 737
    do {\
738 738
        uint8_t *s = src, *d=dst;\
......
1158 1158
#if 1
1159 1159
#define H264_LOWPASS(OPNAME, OP, OP2) \
1160 1160
static inline void OPNAME ## h264_qpel_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,int w,int h){\
1161
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1161
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1162 1162
    do {\
1163 1163
        int srcB,srcA,src0,src1,src2,src3,src4,src5,src6;\
1164 1164
        uint8_t *s = src-2;\
......
1211 1211
}\
1212 1212
\
1213 1213
static inline void OPNAME ## h264_qpel_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,int w,int h){\
1214
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1214
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1215 1215
    do{\
1216 1216
        int srcB,srcA,src0,src1,src2,src3,src4,src5,src6;\
1217 1217
        uint8_t *s = src-2*srcStride,*d=dst;\
......
1264 1264
}\
1265 1265
\
1266 1266
static inline void OPNAME ## h264_qpel_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride,int w,int h){\
1267
    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1267
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1268 1268
    int i;\
1269 1269
    src -= 2*srcStride;\
1270 1270
    i= h+5; \
......
1559 1559
#endif
1560 1560

  
1561 1561
static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
1562
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
1562
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1563 1563

  
1564 1564
    do{
1565 1565
        int src_1,src0,src1,src2,src3,src4,src5,src6,src7,src8,src9;
......
1589 1589
}
1590 1590

  
1591 1591
static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
1592
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
1592
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1593 1593

  
1594 1594
    do{
1595 1595
        int src_1,src0,src1,src2,src3,src4,src5,src6,src7,src8,src9;
libavcodec/simple_idct.c
184 184
                                     DCTELEM * col)
185 185
{
186 186
        int a0, a1, a2, a3, b0, b1, b2, b3;
187
        uint8_t *cm = cropTbl + MAX_NEG_CROP;
187
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
188 188

  
189 189
        /* XXX: I did that only to give same values as previous code */
190 190
        a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
......
256 256
                                     DCTELEM * col)
257 257
{
258 258
        int a0, a1, a2, a3, b0, b1, b2, b3;
259
        uint8_t *cm = cropTbl + MAX_NEG_CROP;
259
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
260 260

  
261 261
        /* XXX: I did that only to give same values as previous code */
262 262
        a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
......
431 431
static inline void idct4col(uint8_t *dest, int line_size, const DCTELEM *col)
432 432
{
433 433
    int c0, c1, c2, c3, a0, a1, a2, a3;
434
    const uint8_t *cm = cropTbl + MAX_NEG_CROP;
434
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
435 435

  
436 436
    a0 = col[8*0];
437 437
    a1 = col[8*2];
......
511 511
static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col)
512 512
{
513 513
    int c0, c1, c2, c3, a0, a1, a2, a3;
514
    const uint8_t *cm = cropTbl + MAX_NEG_CROP;
514
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
515 515

  
516 516
    a0 = col[8*0];
517 517
    a1 = col[8*1];
......
539 539
static inline void idct4row(DCTELEM *row)
540 540
{
541 541
    int c0, c1, c2, c3, a0, a1, a2, a3;
542
    //const uint8_t *cm = cropTbl + MAX_NEG_CROP;
542
    //const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
543 543

  
544 544
    a0 = row[0];
545 545
    a1 = row[1];
libavcodec/svq3.c
147 147
static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
148 148
    const int qmul= svq3_dequant_coeff[qp];
149 149
    int i;
150
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
150
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
151 151

  
152 152
    if (dc) {
153 153
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
libavcodec/vp3dsp.c
42 42
static always_inline void idct(uint8_t *dst, int stride, int16_t *input, int type)
43 43
{
44 44
    int16_t *ip = input;
45
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
45
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
46 46

  
47 47
    int A, B, C, D, Ad, Bd, Cd, Dd, E, F, G, H;
48 48
    int Ed, Gd, Add, Bdd, Fd, Hd;
libavformat/grab.c
760 760
        movq_m2r(rounder,mm6);
761 761
        pxor_r2r(mm7,mm7);
762 762
#else
763
        uint8_t *cm = cropTbl + MAX_NEG_CROP;
763
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
764 764
#endif
765 765

  
766 766
        /* read two fields and deinterlace them */
vhook/fish.c
230 230
void Process(void *ctx, AVPicture *picture, enum PixelFormat pix_fmt, int width, int height, int64_t pts)
231 231
{
232 232
    ContextInfo *ci = (ContextInfo *) ctx;
233
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
233
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
234 234
    int rowsize = picture->linesize[0];
235 235

  
236 236
#if 0

Also available in: Unified diff