← Back to branch summary

~ubuntu-branches/ubuntu/lucid/gavl/lucid

« back to all changes in this revision

Viewing changes to gavl/mmx/scale_x_mmx.c

  • Committer: Bazaar Package Importer
  • Author(s): Romain Beauxis
  • Date: 2008-11-07 13:47:46 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081107134746-s4s970fo1bcde9zw
Tags: 1.0.1-1
* Adopted package for debian, with the blessing of previous maintainer.
* Based new package on Christian Marillat's package for debian-multimedia.
* Removed support for ccache until I figure out how to make it work
  with cdbs.
* Changed library package name since ABI is not backward compatible, but
  upstream did not bump major soversion.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gavl/mmx/scale_x_mmx.c
 
1
/*****************************************************************
 
2
 * gavl - a general purpose audio/video processing library
 
3
 *
 
4
 * Copyright (c) 2001 - 2008 Members of the Gmerlin project
 
5
 * gmerlin-general@lists.sourceforge.net
 
6
 * http://gmerlin.sourceforge.net
 
7
 *
 
8
 * This program is free software: you can redistribute it and/or modify
 
9
 * it under the terms of the GNU General Public License as published by
 
10
 * the Free Software Foundation, either version 2 of the License, or
 
11
 * (at your option) any later version.
 
12
 *
 
13
 * This program is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 * GNU General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU General Public License
 
19
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
20
 * *****************************************************************/
 
21
 
 
22
#include <config.h>
 
23
#include <attributes.h>
 
24
 
 
25
#include <stdio.h>
 
26
#include <gavl/gavl.h>
 
27
#include <video.h>
 
28
#include <scale.h>
 
29
 
 
30
#include "mmx.h"
 
31
 
 
32
#ifdef MMXEXT
 
33
static const mmx_t min_13 = { .uw = { 0x0000, 0x0000, 0x0000, 0x0000 } };
 
34
static const mmx_t max_13 = { .uw = { 0x1FFF, 0x1FFF, 0x1FFF, 0x1FFF } };
 
35
#endif
 
36
 
 
37
#ifdef MMXEXT
 
38
#define MOVQ_R2M(reg,mem) movntq_r2m(reg, mem)
 
39
#else
 
40
#define MOVQ_R2M(reg,mem) movq_r2m(reg, mem)
 
41
#endif
 
42
 
 
43
#if 0
 
44
static mmx_t mm_tmp;
 
45
#define DUMP_MM(name, reg) MOVQ_R2M(reg, mm_tmp);\
 
46
  fprintf(stderr, "%s: %016llx\n", name, mm_tmp.q);
 
47
#endif
 
48
 
 
49
static const mmx_t factor_mask = { 0x000000000000FFFFLL };
 
50
 
 
51
/*
 
52
 *  mm0: Input
 
53
 *  mm1: Input
 
54
 *  mm2: Factor
 
55
 *  mm3: Factor
 
56
 *  mm4: Output
 
57
 *  mm5: Output
 
58
 *  mm6: 0
 
59
 *  mm7: scratch
 
60
 *  
 
61
 */
 
62
 
 
63
//#define LOAD_FACTOR_1
 
64
//#define LOAD_FACTOR_4
 
65
 
 
66
#ifdef MMXEXT
 
67
#define LOAD_FACTOR_1_4 \
 
68
    movd_m2r(*factors, mm2); \
 
69
    pand_r2r(mm1, mm2); \
 
70
    pshufw_r2r(mm2,mm7,0x00)
 
71
 
 
72
#define LOAD_FACTOR_1_4_NOCLIP \
 
73
    movd_m2r(*factors, mm2); \
 
74
    pand_r2r(mm1, mm2); \
 
75
    pshufw_r2r(mm2,mm7,0x00)
 
76
 
 
77
#else
 
78
#define LOAD_FACTOR_1_4 \
 
79
    movd_m2r(*factors, mm2); \
 
80
    pand_r2r(mm1, mm2); \
 
81
    movq_r2r(mm2, mm7); \
 
82
    psllq_i2r(16, mm7); \
 
83
    por_r2r(mm7, mm2); \
 
84
    movq_r2r(mm2, mm7); \
 
85
    psllq_i2r(32, mm7); \
 
86
    por_r2r(mm2, mm7)
 
87
 
 
88
#define LOAD_FACTOR_1_4_NOCLIP \
 
89
    movd_m2r(*factors, mm2); \
 
90
    movq_r2r(mm2, mm7); \
 
91
    psllq_i2r(16, mm7); \
 
92
    por_r2r(mm7, mm2); \
 
93
    movq_r2r(mm2, mm7); \
 
94
    psllq_i2r(32, mm7); \
 
95
    por_r2r(mm2, mm7)
 
96
#endif
 
97
 
 
98
#define RECLIP(a,idx) \
 
99
  if(a < ctx->min_values_h[idx]) a = ctx->min_values_h[idx];    \
 
100
  if(a > ctx->max_values_h[idx]) a = ctx->max_values_h[idx]
 
101
 
 
102
/* scale_uint8_x_1_x_bicubic_mmx */
 
103
 
 
104
#ifndef MMXEXT
 
105
 
 
106
/* scale_uint8_x_1_x_bilinear_mmx */
 
107
 
 
108
static void scale_uint8_x_1_x_bilinear_mmx(gavl_video_scale_context_t * ctx)
 
109
  {
 
110
  int i, imax, index;
 
111
  uint8_t * src, * dst, *src_start;
 
112
  mmx_t tmp_mm;
 
113
 
 
114
  
 
115
/*
 
116
 *  mm0: Input1 Input2
 
117
 *  mm1: Factor
 
118
 *  mm2:
 
119
 *  mm3: 
 
120
 *  mm4: 
 
121
 *  mm5: 
 
122
 *  mm6: 0
 
123
 *  mm7: scratch
 
124
 *  
 
125
 */
 
126
  
 
127
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
128
  
 
129
  pxor_r2r(mm6, mm6);
 
130
  dst = ctx->dst;
 
131
 
 
132
  imax = ctx->dst_size / 4;
 
133
  //  imax = 0;
 
134
  index = 0;
 
135
  
 
136
  for(i = 0; i < imax; i++)
 
137
    {
 
138
    
 
139
    /* Load pixels */
 
140
    src = src_start + ctx->table_h.pixels[index].index;
 
141
    tmp_mm.uw[0] = *src;
 
142
    tmp_mm.uw[1] = *(src+1);
 
143
    
 
144
    src = src_start + ctx->table_h.pixels[index+1].index;
 
145
    tmp_mm.uw[2] = *src;
 
146
    tmp_mm.uw[3] = *(src+1);
 
147
    
 
148
    movq_m2r(tmp_mm, mm0);
 
149
    /* Load factors */
 
150
    movq_m2r(ctx->table_h.pixels[index].factor_i[0], mm1);
 
151
    movq_m2r(ctx->table_h.pixels[index+1].factor_i[0], mm7);
 
152
 
 
153
    packssdw_r2r(mm7, mm1);
 
154
    pmaddwd_r2r(mm0, mm1);
 
155
 
 
156
    index += 2;
 
157
    
 
158
    /* Load pixels */
 
159
    src = src_start + ctx->table_h.pixels[index].index;
 
160
    tmp_mm.uw[0] = *src;
 
161
    tmp_mm.uw[1] = *(src+1);
 
162
    
 
163
    src = src_start + ctx->table_h.pixels[index+1].index;
 
164
    tmp_mm.uw[2] = *src;
 
165
    tmp_mm.uw[3] = *(src+1);
 
166
    
 
167
    movq_m2r(tmp_mm, mm0);
 
168
    /* Load factors */
 
169
    movq_m2r(ctx->table_h.pixels[index].factor_i[0], mm3);
 
170
    movq_m2r(ctx->table_h.pixels[index+1].factor_i[0], mm7);
 
171
    packssdw_r2r(mm7, mm3);
 
172
    pmaddwd_r2r(mm0, mm3);
 
173
    
 
174
    psrld_i2r(7, mm3);
 
175
    psrld_i2r(7, mm1);
 
176
    packssdw_r2r(mm3, mm1);
 
177
    psrlw_i2r(7, mm1);
 
178
    index += 2;
 
179
    
 
180
    packuswb_r2r(mm6, mm1);
 
181
    
 
182
    movd_r2m(mm1, *dst);
 
183
    //    *dst      = tmp_mm.ub[0];
 
184
    //    *(dst+1) = tmp_mm.ub[4];
 
185
    dst+=4;
 
186
    }
 
187
  ctx->need_emms = 1;
 
188
 
 
189
  imax = ctx->dst_size % 4;
 
190
  //  imax = ctx->dst_size;
 
191
  
 
192
  for(i = 0; i < imax; i++)
 
193
    {
 
194
    src = (src_start + ctx->table_h.pixels[index].index);
 
195
    *dst = (ctx->table_h.pixels[index].factor_i[0] * *src +
 
196
      ctx->table_h.pixels[index].factor_i[1] * *(src+1)) >> 14;
 
197
    dst++;
 
198
    index++;
 
199
    }
 
200
  
 
201
  }
 
202
 
 
203
 
 
204
static void scale_uint8_x_1_x_bicubic_mmx(gavl_video_scale_context_t * ctx)
 
205
  {
 
206
  int i;
 
207
  uint8_t * src, * dst, *src_start;
 
208
  int32_t * factors;
 
209
  mmx_t tmp_mm;
 
210
  int32_t tmp;
 
211
  
 
212
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_mmx\n");
 
213
 
 
214
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
215
  
 
216
  pxor_r2r(mm6, mm6);
 
217
  dst = ctx->dst;
 
218
  for(i = 0; i < ctx->dst_size; i++)
 
219
    {
 
220
    src = src_start + ctx->table_h.pixels[i].index;
 
221
    factors = ctx->table_h.pixels[i].factor_i;
 
222
    /* Load pixels */
 
223
    movd_m2r(*(src), mm0);
 
224
    punpcklbw_r2r(mm6, mm0);
 
225
    //    DUMP_MM("mm0", mm0);
 
226
    /* Load factors */
 
227
    movq_m2r(*factors, mm2);
 
228
    movq_m2r(*(factors+2), mm3);
 
229
    packssdw_r2r(mm3, mm2);
 
230
    /* Multiply */
 
231
    pmaddwd_r2r(mm2, mm0);
 
232
    MOVQ_R2M(mm0, tmp_mm);
 
233
    tmp = tmp_mm.d[0] + tmp_mm.d[1];
 
234
    tmp >>= 14;
 
235
    RECLIP(tmp, ctx->plane);
 
236
    *(dst++) = tmp;
 
237
    }
 
238
  ctx->need_emms = 1;
 
239
  }
 
240
 
 
241
static void scale_uint16_x_1_x_bicubic_mmx(gavl_video_scale_context_t * ctx)
 
242
  {
 
243
  int i;
 
244
  uint16_t * dst;
 
245
  uint8_t * src, *src_start;
 
246
  int32_t * factors;
 
247
  mmx_t tmp_mm;
 
248
  int32_t tmp;
 
249
  
 
250
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_mmx\n");
 
251
 
 
252
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
253
  
 
254
  pxor_r2r(mm6, mm6);
 
255
  dst = (uint16_t*)ctx->dst;
 
256
  for(i = 0; i < ctx->dst_size; i++)
 
257
    {
 
258
    src = src_start + 2*ctx->table_h.pixels[i].index;
 
259
    factors = ctx->table_h.pixels[i].factor_i;
 
260
    /* Load pixels */
 
261
    movq_m2r(*(src), mm0);
 
262
    psrlw_i2r(1, mm0);
 
263
    //    DUMP_MM("mm0", mm0);
 
264
    /* Load factors */
 
265
    movq_m2r(*factors, mm2);
 
266
    movq_m2r(*(factors+2), mm3);
 
267
    packssdw_r2r(mm3, mm2);
 
268
    /* Multiply */
 
269
    pmaddwd_r2r(mm2, mm0);
 
270
    MOVQ_R2M(mm0, tmp_mm);
 
271
    tmp = tmp_mm.d[0] + tmp_mm.d[1];
 
272
    tmp >>= 13;
 
273
    RECLIP(tmp, ctx->plane);
 
274
    *(dst++) = tmp;
 
275
    }
 
276
  ctx->need_emms = 1;
 
277
  }
 
278
 
 
279
static void scale_uint16_x_1_x_bicubic_noclip_mmx(gavl_video_scale_context_t * ctx)
 
280
  {
 
281
  int i;
 
282
  uint16_t * dst;
 
283
  uint8_t * src, *src_start;
 
284
  int32_t * factors;
 
285
  mmx_t tmp_mm;
 
286
  int32_t tmp;
 
287
  
 
288
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_mmx\n");
 
289
 
 
290
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
291
  
 
292
  pxor_r2r(mm6, mm6);
 
293
  dst = (uint16_t*)ctx->dst;
 
294
  for(i = 0; i < ctx->dst_size; i++)
 
295
    {
 
296
    src = src_start + 2*ctx->table_h.pixels[i].index;
 
297
    factors = ctx->table_h.pixels[i].factor_i;
 
298
    /* Load pixels */
 
299
    movq_m2r(*(src), mm0);
 
300
    psrlw_i2r(1, mm0);
 
301
    //    DUMP_MM("mm0", mm0);
 
302
    /* Load factors */
 
303
    movq_m2r(*factors, mm2);
 
304
    movq_m2r(*(factors+2), mm3);
 
305
    packssdw_r2r(mm3, mm2);
 
306
    /* Multiply */
 
307
    pmaddwd_r2r(mm2, mm0);
 
308
    MOVQ_R2M(mm0, tmp_mm);
 
309
    tmp = tmp_mm.d[0] + tmp_mm.d[1];
 
310
    tmp >>= 13;
 
311
    *(dst++) = tmp;
 
312
    }
 
313
  ctx->need_emms = 1;
 
314
  }
 
315
 
 
316
/* scale_uint8_x_1_x_bicubic_noclip_mmx */
 
317
 
 
318
static void
 
319
scale_uint8_x_1_x_bicubic_noclip_mmx(gavl_video_scale_context_t * ctx)
 
320
  {
 
321
  int i;
 
322
  uint8_t * src, * dst, *src_start;
 
323
  int32_t * factors;
 
324
  mmx_t tmp_mm;
 
325
  
 
326
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_noclip_mmx\n");
 
327
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
328
  
 
329
  pxor_r2r(mm6, mm6);
 
330
  dst = ctx->dst;
 
331
  for(i = 0; i < ctx->dst_size; i++)
 
332
    {
 
333
    src = src_start + ctx->table_h.pixels[i].index;
 
334
    factors = ctx->table_h.pixels[i].factor_i;
 
335
    /* Load pixels */
 
336
    movd_m2r(*(src), mm0);
 
337
    punpcklbw_r2r(mm6, mm0);
 
338
    /* Load factors */
 
339
    movq_m2r(*factors, mm2);
 
340
    movq_m2r(*(factors+2), mm3);
 
341
    packssdw_r2r(mm3, mm2);
 
342
    /* Multiply */
 
343
    pmaddwd_r2r(mm2, mm0);
 
344
    psrld_i2r(14, mm0);
 
345
    MOVQ_R2M(mm0, tmp_mm);
 
346
    *(dst++) = tmp_mm.d[0] + tmp_mm.d[1];
 
347
    }
 
348
  ctx->need_emms = 1;
 
349
  }
 
350
 
 
351
#endif // !MMXEXT
 
352
 
 
353
/* scale_uint8_x_4_x_bicubic_mmx */
 
354
 
 
355
static void scale_uint8_x_4_x_bicubic_mmx(gavl_video_scale_context_t * ctx)
 
356
  {
 
357
  int i;
 
358
  uint8_t * src, * dst, *src_start;
 
359
  int32_t * factors;
 
360
  //  mmx_t tmp_mm;
 
361
 
 
362
/*
 
363
 *  mm0: Input
 
364
 *  mm1: factor_mask
 
365
 *  mm2: Factor
 
366
 *  mm3: Output
 
367
 *  mm4: 
 
368
 *  mm5: 
 
369
 *  mm6: 0
 
370
 *  mm7: scratch
 
371
 *  
 
372
 */
 
373
  
 
374
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_noclip_mmx\n");
 
375
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
376
  
 
377
  pxor_r2r(mm6, mm6);
 
378
  movq_m2r(factor_mask, mm1);
 
379
  dst = ctx->dst;
 
380
  for(i = 0; i < ctx->dst_size; i++)
 
381
    {
 
382
    src = src_start + 4*ctx->table_h.pixels[i].index;
 
383
    factors = ctx->table_h.pixels[i].factor_i;
 
384
    
 
385
    /* Load pixels */
 
386
    movd_m2r(*(src), mm0);
 
387
    punpcklbw_r2r(mm6, mm0);
 
388
    psllw_i2r(7, mm0);
 
389
    /* Load factors */
 
390
    LOAD_FACTOR_1_4;
 
391
    /* Multiply */
 
392
    pmulhw_r2r(mm7, mm0);
 
393
    movq_r2r(mm0, mm3);
 
394
    //    DUMP_MM("mm3_1", mm3);
 
395
    src += 4;
 
396
    factors++;
 
397
    
 
398
    /* Load pixels */
 
399
    movd_m2r(*(src), mm0);
 
400
    punpcklbw_r2r(mm6, mm0);
 
401
    psllw_i2r(7, mm0);
 
402
    /* Load factors */
 
403
    LOAD_FACTOR_1_4;
 
404
    /* Multiply */
 
405
    pmulhw_r2r(mm7, mm0);
 
406
    paddw_r2r(mm0, mm3);
 
407
    //    DUMP_MM("mm3_2", mm3);
 
408
    src += 4;
 
409
    factors++;
 
410
 
 
411
    /* Load pixels */
 
412
    movd_m2r(*(src), mm0);
 
413
    punpcklbw_r2r(mm6, mm0);
 
414
    psllw_i2r(7, mm0);
 
415
    /* Load factors */
 
416
    LOAD_FACTOR_1_4;
 
417
    /* Multiply */
 
418
    pmulhw_r2r(mm7, mm0);
 
419
    paddw_r2r(mm0, mm3);
 
420
    //    DUMP_MM("mm3_3", mm3);
 
421
    src += 4;
 
422
    factors++;
 
423
 
 
424
    /* Load pixels */
 
425
    movd_m2r(*(src), mm0);
 
426
    punpcklbw_r2r(mm6, mm0);
 
427
    psllw_i2r(7, mm0);
 
428
    /* Load factors */
 
429
    LOAD_FACTOR_1_4;
 
430
    /* Multiply */
 
431
    pmulhw_r2r(mm7, mm0);
 
432
    paddw_r2r(mm0, mm3);
 
433
    src += 4;
 
434
    factors++;
 
435
 
 
436
    psraw_i2r(5, mm3);
 
437
    packuswb_r2r(mm6, mm3);
 
438
    movd_r2m(mm3, *dst);
 
439
    
 
440
    dst+=4;
 
441
    }
 
442
  ctx->need_emms = 1;
 
443
  }
 
444
 
 
445
#ifdef MMXEXT 
 
446
static void scale_uint16_x_4_x_bicubic_mmx(gavl_video_scale_context_t * ctx)
 
447
  {
 
448
  int i;
 
449
  uint8_t * src, * dst, *src_start;
 
450
  int32_t * factors;
 
451
  //  mmx_t tmp_mm;
 
452
 
 
453
/*
 
454
 *  mm0: Input
 
455
 *  mm1: factor_mask
 
456
 *  mm2: Factor
 
457
 *  mm3: Output
 
458
 *  mm4: 
 
459
 *  mm5: 
 
460
 *  mm6: 0
 
461
 *  mm7: scratch
 
462
 *  
 
463
 */
 
464
  
 
465
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_noclip_mmx\n");
 
466
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
467
  
 
468
  pxor_r2r(mm6, mm6);
 
469
  movq_m2r(factor_mask, mm1);
 
470
  dst = ctx->dst;
 
471
  for(i = 0; i < ctx->dst_size; i++)
 
472
    {
 
473
    src = src_start + 8*ctx->table_h.pixels[i].index;
 
474
    factors = ctx->table_h.pixels[i].factor_i;
 
475
    
 
476
    /* Load pixels */
 
477
    movq_m2r(*(src), mm0);
 
478
    //    punpcklbw_r2r(mm6, mm0);
 
479
    psrlw_i2r(1, mm0);
 
480
    /* Load factors */
 
481
    LOAD_FACTOR_1_4;
 
482
    /* Multiply */
 
483
    pmulhw_r2r(mm7, mm0);
 
484
    movq_r2r(mm0, mm3);
 
485
    //    DUMP_MM("mm3_1", mm3);
 
486
    src += 8;
 
487
    factors++;
 
488
    
 
489
    /* Load pixels */
 
490
    movq_m2r(*(src), mm0);
 
491
    //    punpcklbw_r2r(mm6, mm0);
 
492
    psrlw_i2r(1, mm0);
 
493
    /* Load factors */
 
494
    LOAD_FACTOR_1_4;
 
495
    /* Multiply */
 
496
    pmulhw_r2r(mm7, mm0);
 
497
    paddw_r2r(mm0, mm3);
 
498
    //    DUMP_MM("mm3_2", mm3);
 
499
    src += 8;
 
500
    factors++;
 
501
 
 
502
    /* Load pixels */
 
503
    movq_m2r(*(src), mm0);
 
504
    //    punpcklbw_r2r(mm6, mm0);
 
505
    psrlw_i2r(1, mm0);
 
506
    /* Load factors */
 
507
    LOAD_FACTOR_1_4;
 
508
    /* Multiply */
 
509
    pmulhw_r2r(mm7, mm0);
 
510
    paddw_r2r(mm0, mm3);
 
511
    //    DUMP_MM("mm3_3", mm3);
 
512
    src += 8;
 
513
    factors++;
 
514
 
 
515
    /* Load pixels */
 
516
    movq_m2r(*(src), mm0);
 
517
    //    punpcklbw_r2r(mm6, mm0);
 
518
    psrlw_i2r(1, mm0);
 
519
    /* Load factors */
 
520
    LOAD_FACTOR_1_4;
 
521
    /* Multiply */
 
522
    pmulhw_r2r(mm7, mm0);
 
523
    paddw_r2r(mm0, mm3);
 
524
    src += 8;
 
525
    factors++;
 
526
 
 
527
    pminsw_m2r(max_13, mm3);
 
528
    pmaxsw_m2r(min_13, mm3);
 
529
    
 
530
    psllw_i2r(3, mm3);
 
531
    //    packuswb_r2r(mm6, mm3);
 
532
    MOVQ_R2M(mm3, *dst);
 
533
    
 
534
    dst+=8;
 
535
    }
 
536
  ctx->need_emms = 1;
 
537
  }
 
538
 
 
539
#endif // MMXEXT 
 
540
 
 
541
static void scale_uint16_x_4_x_bicubic_noclip_mmx(gavl_video_scale_context_t * ctx)
 
542
  {
 
543
  int i;
 
544
  uint8_t * src, * dst, *src_start;
 
545
  int32_t * factors;
 
546
  //  mmx_t tmp_mm;
 
547
 
 
548
/*
 
549
 *  mm0: Input
 
550
 *  mm1: factor_mask
 
551
 *  mm2: Factor
 
552
 *  mm3: Output
 
553
 *  mm4: 
 
554
 *  mm5: 
 
555
 *  mm6: 0
 
556
 *  mm7: scratch
 
557
 *  
 
558
 */
 
559
  
 
560
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_noclip_mmx\n");
 
561
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
562
  
 
563
  pxor_r2r(mm6, mm6);
 
564
  movq_m2r(factor_mask, mm1);
 
565
  dst = ctx->dst;
 
566
  for(i = 0; i < ctx->dst_size; i++)
 
567
    {
 
568
    src = src_start + 8*ctx->table_h.pixels[i].index;
 
569
    factors = ctx->table_h.pixels[i].factor_i;
 
570
    
 
571
    /* Load pixels */
 
572
    movq_m2r(*(src), mm0);
 
573
    //    punpcklbw_r2r(mm6, mm0);
 
574
    psrlw_i2r(1, mm0);
 
575
    /* Load factors */
 
576
    LOAD_FACTOR_1_4_NOCLIP;
 
577
    /* Multiply */
 
578
    pmulhw_r2r(mm7, mm0);
 
579
    movq_r2r(mm0, mm3);
 
580
    //    DUMP_MM("mm3_1", mm3);
 
581
    src += 8;
 
582
    factors++;
 
583
    
 
584
    /* Load pixels */
 
585
    movq_m2r(*(src), mm0);
 
586
    //    punpcklbw_r2r(mm6, mm0);
 
587
    psrlw_i2r(1, mm0);
 
588
    /* Load factors */
 
589
    LOAD_FACTOR_1_4_NOCLIP;
 
590
    /* Multiply */
 
591
    pmulhw_r2r(mm7, mm0);
 
592
    paddw_r2r(mm0, mm3);
 
593
    //    DUMP_MM("mm3_2", mm3);
 
594
    src += 8;
 
595
    factors++;
 
596
 
 
597
    /* Load pixels */
 
598
    movq_m2r(*(src), mm0);
 
599
    //    punpcklbw_r2r(mm6, mm0);
 
600
    psrlw_i2r(1, mm0);
 
601
    /* Load factors */
 
602
    LOAD_FACTOR_1_4_NOCLIP;
 
603
    /* Multiply */
 
604
    pmulhw_r2r(mm7, mm0);
 
605
    paddw_r2r(mm0, mm3);
 
606
    //    DUMP_MM("mm3_3", mm3);
 
607
    src += 8;
 
608
    factors++;
 
609
 
 
610
    /* Load pixels */
 
611
    movq_m2r(*(src), mm0);
 
612
    //    punpcklbw_r2r(mm6, mm0);
 
613
    psrlw_i2r(1, mm0);
 
614
    /* Load factors */
 
615
    LOAD_FACTOR_1_4_NOCLIP;
 
616
    /* Multiply */
 
617
    pmulhw_r2r(mm7, mm0);
 
618
    paddw_r2r(mm0, mm3);
 
619
    src += 8;
 
620
    factors++;
 
621
 
 
622
    psllw_i2r(3, mm3);
 
623
    //    packuswb_r2r(mm6, mm3);
 
624
    MOVQ_R2M(mm3, *dst);
 
625
    
 
626
    dst+=8;
 
627
    }
 
628
  ctx->need_emms = 1;
 
629
  }
 
630
 
 
631
#ifdef MMXEXT
 
632
static void scale_uint16_x_4_x_quadratic_mmx(gavl_video_scale_context_t * ctx)
 
633
  {
 
634
  int i;
 
635
  uint8_t * src, * dst, *src_start;
 
636
  int32_t * factors;
 
637
  //  mmx_t tmp_mm;
 
638
 
 
639
/*
 
640
 *  mm0: Input
 
641
 *  mm1: factor_mask
 
642
 *  mm2: Factor
 
643
 *  mm3: Output
 
644
 *  mm4: 
 
645
 *  mm5: 
 
646
 *  mm6: 0
 
647
 *  mm7: scratch
 
648
 *  
 
649
 */
 
650
  
 
651
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_noclip_mmx\n");
 
652
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
653
  
 
654
  pxor_r2r(mm6, mm6);
 
655
  movq_m2r(factor_mask, mm1);
 
656
  dst = ctx->dst;
 
657
  for(i = 0; i < ctx->dst_size; i++)
 
658
    {
 
659
    src = src_start + 8*ctx->table_h.pixels[i].index;
 
660
    factors = ctx->table_h.pixels[i].factor_i;
 
661
    
 
662
    /* Load pixels */
 
663
    movq_m2r(*(src), mm0);
 
664
    //    punpcklbw_r2r(mm6, mm0);
 
665
    psrlw_i2r(1, mm0);
 
666
    /* Load factors */
 
667
    LOAD_FACTOR_1_4_NOCLIP;
 
668
    /* Multiply */
 
669
    pmulhw_r2r(mm7, mm0);
 
670
    movq_r2r(mm0, mm3);
 
671
    //    DUMP_MM("mm3_1", mm3);
 
672
    src += 8;
 
673
    factors++;
 
674
    
 
675
    /* Load pixels */
 
676
    movq_m2r(*(src), mm0);
 
677
    //    punpcklbw_r2r(mm6, mm0);
 
678
    psrlw_i2r(1, mm0);
 
679
    /* Load factors */
 
680
    LOAD_FACTOR_1_4_NOCLIP;
 
681
    /* Multiply */
 
682
    pmulhw_r2r(mm7, mm0);
 
683
    paddw_r2r(mm0, mm3);
 
684
    //    DUMP_MM("mm3_2", mm3);
 
685
    src += 8;
 
686
    factors++;
 
687
 
 
688
    /* Load pixels */
 
689
    movq_m2r(*(src), mm0);
 
690
    //    punpcklbw_r2r(mm6, mm0);
 
691
    psrlw_i2r(1, mm0);
 
692
    /* Load factors */
 
693
    LOAD_FACTOR_1_4_NOCLIP;
 
694
    /* Multiply */
 
695
    pmulhw_r2r(mm7, mm0);
 
696
    paddw_r2r(mm0, mm3);
 
697
    //    DUMP_MM("mm3_3", mm3);
 
698
    src += 8;
 
699
    
 
700
    psllw_i2r(3, mm3);
 
701
    //    packuswb_r2r(mm6, mm3);
 
702
    MOVQ_R2M(mm3, *dst);
 
703
    
 
704
    dst+=8;
 
705
    }
 
706
  ctx->need_emms = 1;
 
707
  }
 
708
#endif // MMXEXT
 
709
 
 
710
 
 
711
/* scale_uint8_x_4_x_bicubic_mmx */
 
712
 
 
713
static void scale_uint8_x_4_x_quadratic_mmx(gavl_video_scale_context_t * ctx)
 
714
  {
 
715
  int i;
 
716
  uint8_t * src, * dst, *src_start;
 
717
  int32_t * factors;
 
718
  //  mmx_t tmp_mm;
 
719
 
 
720
/*
 
721
 *  mm0: Input
 
722
 *  mm1: factor_mask
 
723
 *  mm2: Factor
 
724
 *  mm3: Output
 
725
 *  mm4: 
 
726
 *  mm5: 
 
727
 *  mm6: 0
 
728
 *  mm7: scratch
 
729
 *  
 
730
 */
 
731
  
 
732
  //  fprintf(stderr, "scale_uint8_x_1_x_bicubic_noclip_mmx\n");
 
733
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
734
  
 
735
  pxor_r2r(mm6, mm6);
 
736
  movq_m2r(factor_mask, mm1);
 
737
  dst = ctx->dst;
 
738
  for(i = 0; i < ctx->dst_size; i++)
 
739
    {
 
740
    src = src_start + 4*ctx->table_h.pixels[i].index;
 
741
    factors = ctx->table_h.pixels[i].factor_i;
 
742
    
 
743
    /* Load pixels */
 
744
    movd_m2r(*(src), mm0);
 
745
    punpcklbw_r2r(mm6, mm0);
 
746
    psllw_i2r(7, mm0);
 
747
    /* Load factors */
 
748
    LOAD_FACTOR_1_4_NOCLIP;
 
749
    /* Multiply */
 
750
    pmulhw_r2r(mm7, mm0);
 
751
    movq_r2r(mm0, mm3);
 
752
    //    DUMP_MM("mm3_1", mm3);
 
753
    src += 4;
 
754
    factors++;
 
755
    
 
756
    /* Load pixels */
 
757
    movd_m2r(*(src), mm0);
 
758
    punpcklbw_r2r(mm6, mm0);
 
759
    psllw_i2r(7, mm0);
 
760
    /* Load factors */
 
761
    LOAD_FACTOR_1_4_NOCLIP;
 
762
    /* Multiply */
 
763
    pmulhw_r2r(mm7, mm0);
 
764
    paddw_r2r(mm0, mm3);
 
765
    //    DUMP_MM("mm3_2", mm3);
 
766
    src += 4;
 
767
    factors++;
 
768
 
 
769
    /* Load pixels */
 
770
    movd_m2r(*(src), mm0);
 
771
    punpcklbw_r2r(mm6, mm0);
 
772
    psllw_i2r(7, mm0);
 
773
    /* Load factors */
 
774
    LOAD_FACTOR_1_4_NOCLIP;
 
775
    /* Multiply */
 
776
    pmulhw_r2r(mm7, mm0);
 
777
    paddw_r2r(mm0, mm3);
 
778
    //    DUMP_MM("mm3_3", mm3);
 
779
    src += 4;
 
780
    factors++;
 
781
    
 
782
    psraw_i2r(5, mm3);
 
783
    packuswb_r2r(mm6, mm3);
 
784
    movd_r2m(mm3, *dst);
 
785
    
 
786
    dst+=4;
 
787
    }
 
788
  ctx->need_emms = 1;
 
789
  }
 
790
 
 
791
 
 
792
/* scale_uint8_x_1_x_generic_mmx */
 
793
#ifndef MMXEXT
 
794
static void scale_uint8_x_1_x_generic_mmx(gavl_video_scale_context_t * ctx)
 
795
  {
 
796
  int i, j, jmax;
 
797
  uint8_t * src, * dst, *src_start;
 
798
  int32_t * factors;
 
799
  mmx_t tmp_mm;
 
800
  int tmp;
 
801
  
 
802
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
803
  
 
804
  pxor_r2r(mm6, mm6);
 
805
  dst = ctx->dst;
 
806
  for(i = 0; i < ctx->dst_size; i++)
 
807
    {
 
808
    src = src_start + ctx->table_h.pixels[i].index;
 
809
    factors = ctx->table_h.pixels[i].factor_i;
 
810
 
 
811
    jmax = ctx->table_h.factors_per_pixel / 4;
 
812
    tmp = 0;
 
813
#if 1
 
814
    pxor_r2r(mm4, mm4);
 
815
 
 
816
    for(j = 0; j < jmax; j++)
 
817
      {
 
818
      /* Load pixels */
 
819
      movd_m2r(*(src), mm0);
 
820
      punpcklbw_r2r(mm6, mm0);
 
821
      //    DUMP_MM("mm0", mm0);
 
822
      /* Load factors */
 
823
      movq_m2r(*factors, mm2);
 
824
      movq_m2r(*(factors+2), mm3);
 
825
      packssdw_r2r(mm3, mm2);
 
826
      /* Multiply */
 
827
      pmaddwd_r2r(mm2, mm0);
 
828
      paddd_r2r(mm0, mm4);
 
829
      src += 4;
 
830
      factors += 4;
 
831
      }
 
832
 
 
833
    MOVQ_R2M(mm4, tmp_mm);
 
834
    tmp = tmp_mm.d[0] + tmp_mm.d[1];
 
835
 
 
836
    
 
837
    jmax = ctx->table_h.factors_per_pixel % 4;
 
838
#else
 
839
    jmax = ctx->table_h.factors_per_pixel;
 
840
#endif    
 
841
    for(j = 0; j < jmax; j++)
 
842
      {
 
843
      tmp += *factors * *src;
 
844
      factors++;
 
845
      src++;
 
846
      }
 
847
 
 
848
    
 
849
    //    if(tmp > (255 << 14)) tmp = 255 << 14;
 
850
    //    if(tmp < 0) tmp = 0;
 
851
    tmp >>= 14;
 
852
    RECLIP(tmp, ctx->plane);
 
853
    *(dst++) = tmp;
 
854
    
 
855
    }
 
856
  ctx->need_emms = 1;
 
857
  }
 
858
 
 
859
static void scale_uint16_x_1_x_generic_mmx(gavl_video_scale_context_t * ctx)
 
860
  {
 
861
  int i, j, jmax;
 
862
  uint16_t * src, * dst;
 
863
  uint8_t * src_start;
 
864
  int32_t * factors;
 
865
  mmx_t tmp_mm;
 
866
  int tmp;
 
867
  
 
868
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
869
  
 
870
  pxor_r2r(mm6, mm6);
 
871
  dst = (uint16_t*)ctx->dst;
 
872
  for(i = 0; i < ctx->dst_size; i++)
 
873
    {
 
874
    src = (uint16_t*)(src_start + 2*ctx->table_h.pixels[i].index);
 
875
    factors = ctx->table_h.pixels[i].factor_i;
 
876
 
 
877
    jmax = ctx->table_h.factors_per_pixel / 4;
 
878
    tmp = 0;
 
879
#if 1
 
880
    pxor_r2r(mm4, mm4);
 
881
 
 
882
    for(j = 0; j < jmax; j++)
 
883
      {
 
884
      /* Load pixels */
 
885
      movq_m2r(*(src), mm0);
 
886
      psrlw_i2r(1, mm0);
 
887
      //    DUMP_MM("mm0", mm0);
 
888
      /* Load factors */
 
889
      movq_m2r(*factors, mm2);
 
890
      movq_m2r(*(factors+2), mm3);
 
891
      packssdw_r2r(mm3, mm2);
 
892
      /* Multiply */
 
893
      pmaddwd_r2r(mm2, mm0);
 
894
      paddd_r2r(mm0, mm4);
 
895
      src += 4;
 
896
      factors += 4;
 
897
      }
 
898
 
 
899
    MOVQ_R2M(mm4, tmp_mm);
 
900
    tmp = tmp_mm.d[0] + tmp_mm.d[1];
 
901
 
 
902
    
 
903
    jmax = ctx->table_h.factors_per_pixel % 4;
 
904
#else
 
905
    jmax = ctx->table_h.factors_per_pixel;
 
906
#endif    
 
907
    for(j = 0; j < jmax; j++)
 
908
      {
 
909
      tmp += *factors * ((*src)>>1);
 
910
      factors++;
 
911
      src++;
 
912
      }
 
913
 
 
914
    
 
915
    //    if(tmp > (255 << 14)) tmp = 255 << 14;
 
916
    //    if(tmp < 0) tmp = 0;
 
917
    tmp >>= 13;
 
918
    RECLIP(tmp, ctx->plane);
 
919
    *(dst++) = tmp;
 
920
    
 
921
    }
 
922
  ctx->need_emms = 1;
 
923
  }
 
924
 
 
925
 
 
926
#endif // !MMXEXT
 
927
 
 
928
/* scale_uint8_x_4_x_generic_mmx */
 
929
 
 
930
static void scale_uint8_x_4_x_generic_mmx(gavl_video_scale_context_t * ctx)
 
931
  {
 
932
  int i, j;
 
933
  uint8_t * src, * dst, *src_start;
 
934
  int32_t * factors;
 
935
  //  mmx_t tmp_mm;
 
936
 
 
937
/*
 
938
 *  mm0: Input
 
939
 *  mm1: factor_mask
 
940
 *  mm2: Factor
 
941
 *  mm3: Output
 
942
 *  mm4: 
 
943
 *  mm5: 
 
944
 *  mm6: 0
 
945
 *  mm7: scratch
 
946
 *  
 
947
 */
 
948
  
 
949
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
950
  
 
951
  pxor_r2r(mm6, mm6);
 
952
  movq_m2r(factor_mask, mm1);
 
953
  dst = ctx->dst;
 
954
  for(i = 0; i < ctx->dst_size; i++)
 
955
    {
 
956
    src = src_start + 4*ctx->table_h.pixels[i].index;
 
957
    factors = ctx->table_h.pixels[i].factor_i;
 
958
    pxor_r2r(mm3, mm3);
 
959
 
 
960
    for(j = 0; j < ctx->table_h.factors_per_pixel; j++)
 
961
      {
 
962
      /* Load pixels */
 
963
      movd_m2r(*(src), mm0);
 
964
      punpcklbw_r2r(mm6, mm0);
 
965
      psllw_i2r(7, mm0);
 
966
      /* Load factors */
 
967
      LOAD_FACTOR_1_4;
 
968
      /* Multiply */
 
969
      pmulhw_r2r(mm7, mm0);
 
970
      paddw_r2r(mm0, mm3);
 
971
      //    DUMP_MM("mm3_2", mm3);
 
972
      src += 4;
 
973
      factors++;
 
974
      
 
975
      }
 
976
    
 
977
    psraw_i2r(5, mm3);
 
978
    packuswb_r2r(mm6, mm3);
 
979
    movd_r2m(mm3, *dst);
 
980
    
 
981
    dst+=4;
 
982
    }
 
983
  ctx->need_emms = 1;
 
984
  
 
985
  }
 
986
 
 
987
#ifdef MMXEXT
 
988
static void scale_uint16_x_4_x_generic_mmx(gavl_video_scale_context_t * ctx)
 
989
  {
 
990
  int i, j;
 
991
  uint8_t * src, * dst, *src_start;
 
992
  int32_t * factors;
 
993
  //  mmx_t tmp_mm;
 
994
 
 
995
/*
 
996
 *  mm0: Input
 
997
 *  mm1: factor_mask
 
998
 *  mm2: Factor
 
999
 *  mm3: Output
 
1000
 *  mm4: 
 
1001
 *  mm5: 
 
1002
 *  mm6: 0
 
1003
 *  mm7: scratch
 
1004
 *  
 
1005
 */
 
1006
  
 
1007
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
1008
  
 
1009
  pxor_r2r(mm6, mm6);
 
1010
  movq_m2r(factor_mask, mm1);
 
1011
  dst = ctx->dst;
 
1012
  for(i = 0; i < ctx->dst_size; i++)
 
1013
    {
 
1014
    src = src_start + 8*ctx->table_h.pixels[i].index;
 
1015
    factors = ctx->table_h.pixels[i].factor_i;
 
1016
    pxor_r2r(mm3, mm3);
 
1017
 
 
1018
    for(j = 0; j < ctx->table_h.factors_per_pixel; j++)
 
1019
      {
 
1020
      /* Load pixels */
 
1021
      movq_m2r(*(src), mm0);
 
1022
      psrlw_i2r(1, mm0);
 
1023
      /* Load factors */
 
1024
      LOAD_FACTOR_1_4;
 
1025
      /* Multiply */
 
1026
      pmulhw_r2r(mm7, mm0);
 
1027
      paddw_r2r(mm0, mm3);
 
1028
      //    DUMP_MM("mm3_2", mm3);
 
1029
      src += 8;
 
1030
      factors++;
 
1031
      }
 
1032
    pminsw_m2r(max_13, mm3);
 
1033
    pmaxsw_m2r(min_13, mm3);
 
1034
    
 
1035
    psllw_i2r(3, mm3);
 
1036
    MOVQ_R2M(mm3, *dst);
 
1037
    
 
1038
    dst+=8;
 
1039
    }
 
1040
  ctx->need_emms = 1;
 
1041
  
 
1042
  }
 
1043
 
 
1044
 
 
1045
#endif
 
1046
 
 
1047
/* scale_uint8_x_4_x_bilinear_mmx */
 
1048
 
 
1049
static void scale_uint8_x_4_x_bilinear_mmx(gavl_video_scale_context_t * ctx)
 
1050
  {
 
1051
  int i;
 
1052
  uint8_t * src, * dst, *src_start;
 
1053
  int32_t * factors;
 
1054
  //  mmx_t tmp_mm;
 
1055
 
 
1056
/*
 
1057
 *  mm0: Input1
 
1058
 *  mm1: Factor mask
 
1059
 *  mm2: 
 
1060
 *  mm3: Output
 
1061
 *  mm4: 
 
1062
 *  mm5: Input2
 
1063
 *  mm6: 0
 
1064
 *  mm7: Factor
 
1065
 *  
 
1066
 */
 
1067
 
 
1068
//  fprintf(stderr, "scale_uint8_x_4_x_bilinear_mmx\n");
 
1069
  
 
1070
  src_start = ctx->src + ctx->scanline * ctx->src_stride;
 
1071
  
 
1072
  pxor_r2r(mm6, mm6);
 
1073
  movq_m2r(factor_mask, mm1);
 
1074
  dst = ctx->dst;
 
1075
  for(i = 0; i < ctx->dst_size; i++)
 
1076
    {
 
1077
    src = src_start + 4*ctx->table_h.pixels[i].index;
 
1078
    factors = ctx->table_h.pixels[i].factor_i;
 
1079
    
 
1080
    /* Load pixels */
 
1081
    movd_m2r(*(src), mm0);
 
1082
    punpcklbw_r2r(mm6, mm0);
 
1083
    psllw_i2r(6, mm0); /* 14 bit */
 
1084
    /* Load pixels */
 
1085
    movd_m2r(*(src+4), mm5);
 
1086
    punpcklbw_r2r(mm6, mm5);
 
1087
    psllw_i2r(6, mm5); /* 14 bit */
 
1088
 
 
1089
    /* Load factors */
 
1090
    LOAD_FACTOR_1_4_NOCLIP; /* 14 bit */
 
1091
    /* Subtract */
 
1092
    psubsw_r2r(mm5, mm0); /* s1(mm0) - s2(mm5) -> mm0 (14 bit) */
 
1093
    pmulhw_r2r(mm7, mm0); /* factor * (s2 - s1) -> mm0 (12 bit) */
 
1094
    
 
1095
    psllw_i2r(2, mm0); /* (14 bit) */
 
1096
    
 
1097
    paddsw_r2r(mm5, mm0);/* (15 bit) */
 
1098
    
 
1099
    psraw_i2r(6, mm0);/* (8 bit) */
 
1100
    packuswb_r2r(mm6, mm0);
 
1101
    movd_r2m(mm0, *dst);
 
1102
    
 
1103
    dst+=4;
 
1104
    }
 
1105
  ctx->need_emms = 1;
 
1106
  
 
1107
  }
 
1108
 
 
1109
#ifdef MMXEXT
 
1110
void gavl_init_scale_funcs_bicubic_x_mmxext(gavl_scale_funcs_t * tab,
 
1111
                                         int src_advance, int dst_advance)
 
1112
#else
 
1113
void gavl_init_scale_funcs_bicubic_x_mmx(gavl_scale_funcs_t * tab,
 
1114
                                         int src_advance, int dst_advance)
 
1115
#endif
 
1116
  {
 
1117
  if((src_advance == 1) && (dst_advance == 1))
 
1118
    {
 
1119
#ifndef MMXEXT
 
1120
    tab->funcs_x.scale_uint8_x_1_noadvance =  scale_uint8_x_1_x_bicubic_mmx;
 
1121
    tab->funcs_x.bits_uint8_noadvance = 14;
 
1122
#endif
 
1123
    }
 
1124
  else if((src_advance == 2) && (dst_advance == 2))
 
1125
    {
 
1126
#ifndef MMXEXT
 
1127
    tab->funcs_x.scale_uint16_x_1 =  scale_uint16_x_1_x_bicubic_mmx;
 
1128
    tab->funcs_x.bits_uint16 = 14;
 
1129
#endif
 
1130
    }
 
1131
  else if((src_advance == 4) && (dst_advance == 4))
 
1132
    {
 
1133
    tab->funcs_x.scale_uint8_x_3 =  scale_uint8_x_4_x_bicubic_mmx;
 
1134
    tab->funcs_x.scale_uint8_x_4 =  scale_uint8_x_4_x_bicubic_mmx;
 
1135
    tab->funcs_x.bits_uint8_noadvance  = 14;
 
1136
    }
 
1137
  else if((src_advance == 8) && (dst_advance == 8))
 
1138
    {
 
1139
#ifdef MMXEXT
 
1140
    tab->funcs_x.scale_uint16_x_4 = scale_uint16_x_4_x_bicubic_mmx;
 
1141
    tab->funcs_x.bits_uint16 = 14;
 
1142
#endif
 
1143
    }
 
1144
  }
 
1145
 
 
1146
#ifdef MMXEXT
 
1147
void gavl_init_scale_funcs_bicubic_noclip_x_mmxext(gavl_scale_funcs_t * tab,
 
1148
                                                   int src_advance, int dst_advance)
 
1149
#else
 
1150
void gavl_init_scale_funcs_bicubic_noclip_x_mmx(gavl_scale_funcs_t * tab,
 
1151
                                                int src_advance, int dst_advance)
 
1152
#endif
 
1153
  {
 
1154
  if((src_advance == 1) && (dst_advance == 1))
 
1155
    {
 
1156
#ifndef MMXEXT
 
1157
    tab->funcs_x.scale_uint8_x_1_noadvance =  scale_uint8_x_1_x_bicubic_noclip_mmx;
 
1158
    tab->funcs_x.bits_uint8_noadvance = 14;
 
1159
#endif
 
1160
    }
 
1161
  else if((src_advance == 2) && (dst_advance == 2))
 
1162
    {
 
1163
#ifndef MMXEXT
 
1164
    tab->funcs_x.scale_uint16_x_1 =  scale_uint16_x_1_x_bicubic_noclip_mmx;
 
1165
    tab->funcs_x.bits_uint16 = 14;
 
1166
#endif
 
1167
    }
 
1168
#if 1  
 
1169
  else if((src_advance == 4) && (dst_advance == 4))
 
1170
    {
 
1171
    tab->funcs_x.scale_uint8_x_3 =  scale_uint8_x_4_x_bicubic_mmx;
 
1172
    tab->funcs_x.scale_uint8_x_4 =  scale_uint8_x_4_x_bicubic_mmx;
 
1173
    tab->funcs_x.bits_uint8_noadvance  = 14;
 
1174
    }
 
1175
#endif
 
1176
  else if((src_advance == 8) && (dst_advance == 8))
 
1177
    {
 
1178
    tab->funcs_x.scale_uint16_x_4 = scale_uint16_x_4_x_bicubic_noclip_mmx;
 
1179
    tab->funcs_x.bits_uint16 = 14;
 
1180
    }
 
1181
  }
 
1182
 
 
1183
 
 
1184
#ifdef MMXEXT
 
1185
void gavl_init_scale_funcs_quadratic_x_mmxext(gavl_scale_funcs_t * tab,
 
1186
                                              int src_advance, int dst_advance)
 
1187
#else
 
1188
void gavl_init_scale_funcs_quadratic_x_mmx(gavl_scale_funcs_t * tab,
 
1189
                                           int src_advance, int dst_advance)
 
1190
#endif
 
1191
  {
 
1192
  if((src_advance == 4) && (dst_advance == 4))
 
1193
    {
 
1194
    tab->funcs_x.scale_uint8_x_3 =  scale_uint8_x_4_x_quadratic_mmx;
 
1195
    tab->funcs_x.scale_uint8_x_4 =  scale_uint8_x_4_x_quadratic_mmx;
 
1196
    tab->funcs_x.bits_uint8_noadvance  = 14;
 
1197
    }
 
1198
  else if((src_advance == 8) && (dst_advance == 8))
 
1199
    {
 
1200
#ifdef MMXEXT 
 
1201
    tab->funcs_x.scale_uint16_x_4 = scale_uint16_x_4_x_quadratic_mmx;
 
1202
    tab->funcs_x.bits_uint16 = 14;
 
1203
#endif
 
1204
    }
 
1205
  }
 
1206
 
 
1207
#ifdef MMXEXT
 
1208
void gavl_init_scale_funcs_generic_x_mmxext(gavl_scale_funcs_t * tab,
 
1209
                                            int src_advance, int dst_advance)
 
1210
#else
 
1211
void gavl_init_scale_funcs_generic_x_mmx(gavl_scale_funcs_t * tab,
 
1212
                                         int src_advance, int dst_advance)
 
1213
#endif
 
1214
  {
 
1215
  if((src_advance == 1) && (dst_advance == 1))
 
1216
    {
 
1217
#ifndef MMXEXT
 
1218
    tab->funcs_x.scale_uint8_x_1_noadvance =  scale_uint8_x_1_x_generic_mmx;
 
1219
    tab->funcs_x.bits_uint8_noadvance = 14;
 
1220
#endif
 
1221
    }
 
1222
  if((src_advance == 2) && (dst_advance == 2))
 
1223
    {
 
1224
#ifndef MMXEXT
 
1225
    tab->funcs_x.scale_uint16_x_1 =  scale_uint16_x_1_x_generic_mmx;
 
1226
    tab->funcs_x.bits_uint16 = 14;
 
1227
#endif
 
1228
    }
 
1229
  else if((src_advance == 4) && (dst_advance == 4))
 
1230
    {
 
1231
    tab->funcs_x.scale_uint8_x_3 =  scale_uint8_x_4_x_generic_mmx;
 
1232
    tab->funcs_x.scale_uint8_x_4 =  scale_uint8_x_4_x_generic_mmx;
 
1233
    tab->funcs_x.bits_uint8_noadvance  = 14;
 
1234
    }
 
1235
  else if((src_advance == 8) && (dst_advance == 8))
 
1236
    {
 
1237
#ifdef MMXEXT 
 
1238
    tab->funcs_x.scale_uint16_x_4 = scale_uint16_x_4_x_generic_mmx;
 
1239
    tab->funcs_x.bits_uint16 = 14;
 
1240
#endif
 
1241
    }
 
1242
  }
 
1243
 
 
1244
#ifdef MMXEXT
 
1245
void gavl_init_scale_funcs_bilinear_x_mmxext(gavl_scale_funcs_t * tab,
 
1246
                                             int src_advance, int dst_advance)
 
1247
#else
 
1248
void gavl_init_scale_funcs_bilinear_x_mmx(gavl_scale_funcs_t * tab,
 
1249
                                         int src_advance, int dst_advance)
 
1250
#endif
 
1251
  {
 
1252
  if((src_advance == 1) && (dst_advance == 1))
 
1253
    {
 
1254
#ifndef MMXEXT
 
1255
    tab->funcs_x.scale_uint8_x_1_noadvance =  scale_uint8_x_1_x_bilinear_mmx;
 
1256
    tab->funcs_x.bits_uint8_noadvance = 14;
 
1257
#endif
 
1258
    }
 
1259
  else if((src_advance == 4) && (dst_advance == 4))
 
1260
    {
 
1261
    tab->funcs_x.scale_uint8_x_3 =  scale_uint8_x_4_x_bilinear_mmx;
 
1262
    tab->funcs_x.scale_uint8_x_4 =  scale_uint8_x_4_x_bilinear_mmx;
 
1263
    tab->funcs_x.bits_uint8_noadvance  = 14;
 
1264
    }
 
1265
  
 
1266
  }