falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
39047 Commits
32 Branches
789MB
Tree: dc4d726bab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dc4d726bab'
${ noResults }
FFmpeg/libavcodec/ppc/hpeldsp_altivec.c

468 lines
18KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2002 Brian Foley

  3.  * Copyright (c) 2002 Dieter Shirley

  4.  * Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>

  5.  *

  6.  * This file is part of Libav.

  7.  *

  8.  * Libav is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * Libav 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 GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with Libav; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  */

  22. 

  23. #include "config.h"

  24. 

  25. #if HAVE_ALTIVEC_H

  26. #include <altivec.h>

  27. #endif

  28. 

  29. #include "libavutil/attributes.h"

  30. #include "libavutil/cpu.h"

  31. #include "libavutil/ppc/types_altivec.h"

  32. #include "libavutil/ppc/util_altivec.h"

  33. #include "libavcodec/hpeldsp.h"

  34. #include "dsputil_altivec.h"

  35. 

  36. #if HAVE_ALTIVEC

  37. /* next one assumes that ((line_size % 16) == 0) */

  38. void ff_put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)

  39. {

  40.     register vector unsigned char pixelsv1, pixelsv2;

  41.     register vector unsigned char pixelsv1B, pixelsv2B;

  42.     register vector unsigned char pixelsv1C, pixelsv2C;

  43.     register vector unsigned char pixelsv1D, pixelsv2D;

  44. 

  45.     register vector unsigned char perm = vec_lvsl(0, pixels);

  46.     int i;

  47.     register ptrdiff_t line_size_2 = line_size << 1;

  48.     register ptrdiff_t line_size_3 = line_size + line_size_2;

  49.     register ptrdiff_t line_size_4 = line_size << 2;

  50. 

  51. // hand-unrolling the loop by 4 gains about 15%

  52. // mininum execution time goes from 74 to 60 cycles

  53. // it's faster than -funroll-loops, but using

  54. // -funroll-loops w/ this is bad - 74 cycles again.

  55. // all this is on a 7450, tuning for the 7450

  56.     for (i = 0; i < h; i += 4) {

  57.         pixelsv1  = vec_ld( 0, pixels);

  58.         pixelsv2  = vec_ld(15, pixels);

  59.         pixelsv1B = vec_ld(line_size, pixels);

  60.         pixelsv2B = vec_ld(15 + line_size, pixels);

  61.         pixelsv1C = vec_ld(line_size_2, pixels);

  62.         pixelsv2C = vec_ld(15 + line_size_2, pixels);

  63.         pixelsv1D = vec_ld(line_size_3, pixels);

  64.         pixelsv2D = vec_ld(15 + line_size_3, pixels);

  65.         vec_st(vec_perm(pixelsv1, pixelsv2, perm),

  66.                0, (unsigned char*)block);

  67.         vec_st(vec_perm(pixelsv1B, pixelsv2B, perm),

  68.                line_size, (unsigned char*)block);

  69.         vec_st(vec_perm(pixelsv1C, pixelsv2C, perm),

  70.                line_size_2, (unsigned char*)block);

  71.         vec_st(vec_perm(pixelsv1D, pixelsv2D, perm),

  72.                line_size_3, (unsigned char*)block);

  73.         pixels+=line_size_4;

  74.         block +=line_size_4;

  75.     }

  76. }

  77. 

  78. /* next one assumes that ((line_size % 16) == 0) */

  79. #define op_avg(a,b)  a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEUL)>>1) )

  80. void ff_avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)

  81. {

  82.     register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv;

  83.     register vector unsigned char perm = vec_lvsl(0, pixels);

  84.     int i;

  85. 

  86.     for (i = 0; i < h; i++) {

  87.         pixelsv1 = vec_ld( 0, pixels);

  88.         pixelsv2 = vec_ld(16,pixels);

  89.         blockv = vec_ld(0, block);

  90.         pixelsv = vec_perm(pixelsv1, pixelsv2, perm);

  91.         blockv = vec_avg(blockv,pixelsv);

  92.         vec_st(blockv, 0, (unsigned char*)block);

  93.         pixels+=line_size;

  94.         block +=line_size;

  95.     }

  96. }

  97. 

  98. /* next one assumes that ((line_size % 8) == 0) */

  99. static void avg_pixels8_altivec(uint8_t * block, const uint8_t * pixels, ptrdiff_t line_size, int h)

  100. {

  101.     register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv;

  102.     int i;

  103. 

  104.    for (i = 0; i < h; i++) {

  105.        /* block is 8 bytes-aligned, so we're either in the

  106.           left block (16 bytes-aligned) or in the right block (not) */

  107.        int rightside = ((unsigned long)block & 0x0000000F);

  108. 

  109.        blockv = vec_ld(0, block);

  110.        pixelsv1 = vec_ld( 0, pixels);

  111.        pixelsv2 = vec_ld(16, pixels);

  112.        pixelsv = vec_perm(pixelsv1, pixelsv2, vec_lvsl(0, pixels));

  113. 

  114.        if (rightside) {

  115.            pixelsv = vec_perm(blockv, pixelsv, vcprm(0,1,s0,s1));

  116.        } else {

  117.            pixelsv = vec_perm(blockv, pixelsv, vcprm(s0,s1,2,3));

  118.        }

  119. 

  120.        blockv = vec_avg(blockv, pixelsv);

  121. 

  122.        vec_st(blockv, 0, block);

  123. 

  124.        pixels += line_size;

  125.        block += line_size;

  126.    }

  127. }

  128. 

  129. /* next one assumes that ((line_size % 8) == 0) */

  130. static void put_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)

  131. {

  132.     register int i;

  133.     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;

  134.     register vector unsigned char blockv, temp1, temp2;

  135.     register vector unsigned short pixelssum1, pixelssum2, temp3;

  136.     register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);

  137.     register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);

  138. 

  139.     temp1 = vec_ld(0, pixels);

  140.     temp2 = vec_ld(16, pixels);

  141.     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));

  142.     if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F) {

  143.         pixelsv2 = temp2;

  144.     } else {

  145.         pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));

  146.     }

  147.     pixelsv1 = vec_mergeh(vczero, pixelsv1);

  148.     pixelsv2 = vec_mergeh(vczero, pixelsv2);

  149.     pixelssum1 = vec_add((vector unsigned short)pixelsv1,

  150.                          (vector unsigned short)pixelsv2);

  151.     pixelssum1 = vec_add(pixelssum1, vctwo);

  152. 

  153.     for (i = 0; i < h ; i++) {

  154.         int rightside = ((unsigned long)block & 0x0000000F);

  155.         blockv = vec_ld(0, block);

  156. 

  157.         temp1 = vec_ld(line_size, pixels);

  158.         temp2 = vec_ld(line_size + 16, pixels);

  159.         pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));

  160.         if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F) {

  161.             pixelsv2 = temp2;

  162.         } else {

  163.             pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));

  164.         }

  165. 

  166.         pixelsv1 = vec_mergeh(vczero, pixelsv1);

  167.         pixelsv2 = vec_mergeh(vczero, pixelsv2);

  168.         pixelssum2 = vec_add((vector unsigned short)pixelsv1,

  169.                              (vector unsigned short)pixelsv2);

  170.         temp3 = vec_add(pixelssum1, pixelssum2);

  171.         temp3 = vec_sra(temp3, vctwo);

  172.         pixelssum1 = vec_add(pixelssum2, vctwo);

  173.         pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero);

  174. 

  175.         if (rightside) {

  176.             blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1));

  177.         } else {

  178.             blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3));

  179.         }

  180. 

  181.         vec_st(blockv, 0, block);

  182. 

  183.         block += line_size;

  184.         pixels += line_size;

  185.     }

  186. }

  187. 

  188. /* next one assumes that ((line_size % 8) == 0) */

  189. static void put_no_rnd_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)

  190. {

  191.     register int i;

  192.     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;

  193.     register vector unsigned char blockv, temp1, temp2;

  194.     register vector unsigned short pixelssum1, pixelssum2, temp3;

  195.     register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);

  196.     register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1);

  197.     register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);

  198. 

  199.     temp1 = vec_ld(0, pixels);

  200.     temp2 = vec_ld(16, pixels);

  201.     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));

  202.     if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F) {

  203.         pixelsv2 = temp2;

  204.     } else {

  205.         pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));

  206.     }

  207.     pixelsv1 = vec_mergeh(vczero, pixelsv1);

  208.     pixelsv2 = vec_mergeh(vczero, pixelsv2);

  209.     pixelssum1 = vec_add((vector unsigned short)pixelsv1,

  210.                          (vector unsigned short)pixelsv2);

  211.     pixelssum1 = vec_add(pixelssum1, vcone);

  212. 

  213.     for (i = 0; i < h ; i++) {

  214.         int rightside = ((unsigned long)block & 0x0000000F);

  215.         blockv = vec_ld(0, block);

  216. 

  217.         temp1 = vec_ld(line_size, pixels);

  218.         temp2 = vec_ld(line_size + 16, pixels);

  219.         pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));

  220.         if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F) {

  221.             pixelsv2 = temp2;

  222.         } else {

  223.             pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));

  224.         }

  225. 

  226.         pixelsv1 = vec_mergeh(vczero, pixelsv1);

  227.         pixelsv2 = vec_mergeh(vczero, pixelsv2);

  228.         pixelssum2 = vec_add((vector unsigned short)pixelsv1,

  229.                              (vector unsigned short)pixelsv2);

  230.         temp3 = vec_add(pixelssum1, pixelssum2);

  231.         temp3 = vec_sra(temp3, vctwo);

  232.         pixelssum1 = vec_add(pixelssum2, vcone);

  233.         pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero);

  234. 

  235.         if (rightside) {

  236.             blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1));

  237.         } else {

  238.             blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3));

  239.         }

  240. 

  241.         vec_st(blockv, 0, block);

  242. 

  243.         block += line_size;

  244.         pixels += line_size;

  245.     }

  246. }

  247. 

  248. /* next one assumes that ((line_size % 16) == 0) */

  249. static void put_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, ptrdiff_t line_size, int h)

  250. {

  251.     register int i;

  252.     register vector unsigned char pixelsv1, pixelsv2, pixelsv3, pixelsv4;

  253.     register vector unsigned char blockv, temp1, temp2;

  254.     register vector unsigned short temp3, temp4,

  255.         pixelssum1, pixelssum2, pixelssum3, pixelssum4;

  256.     register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);

  257.     register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);

  258. 

  259.     temp1 = vec_ld(0, pixels);

  260.     temp2 = vec_ld(16, pixels);

  261.     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));

  262.     if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F) {

  263.         pixelsv2 = temp2;

  264.     } else {

  265.         pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));

  266.     }

  267.     pixelsv3 = vec_mergel(vczero, pixelsv1);

  268.     pixelsv4 = vec_mergel(vczero, pixelsv2);

  269.     pixelsv1 = vec_mergeh(vczero, pixelsv1);

  270.     pixelsv2 = vec_mergeh(vczero, pixelsv2);

  271.     pixelssum3 = vec_add((vector unsigned short)pixelsv3,

  272.                          (vector unsigned short)pixelsv4);

  273.     pixelssum3 = vec_add(pixelssum3, vctwo);

  274.     pixelssum1 = vec_add((vector unsigned short)pixelsv1,

  275.                          (vector unsigned short)pixelsv2);

  276.     pixelssum1 = vec_add(pixelssum1, vctwo);

  277. 

  278.     for (i = 0; i < h ; i++) {

  279.         blockv = vec_ld(0, block);

  280. 

  281.         temp1 = vec_ld(line_size, pixels);

  282.         temp2 = vec_ld(line_size + 16, pixels);

  283.         pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));

  284.         if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F) {

  285.             pixelsv2 = temp2;

  286.         } else {

  287.             pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));

  288.         }

  289. 

  290.         pixelsv3 = vec_mergel(vczero, pixelsv1);

  291.         pixelsv4 = vec_mergel(vczero, pixelsv2);

  292.         pixelsv1 = vec_mergeh(vczero, pixelsv1);

  293.         pixelsv2 = vec_mergeh(vczero, pixelsv2);

  294. 

  295.         pixelssum4 = vec_add((vector unsigned short)pixelsv3,

  296.                              (vector unsigned short)pixelsv4);

  297.         pixelssum2 = vec_add((vector unsigned short)pixelsv1,

  298.                              (vector unsigned short)pixelsv2);

  299.         temp4 = vec_add(pixelssum3, pixelssum4);

  300.         temp4 = vec_sra(temp4, vctwo);

  301.         temp3 = vec_add(pixelssum1, pixelssum2);

  302.         temp3 = vec_sra(temp3, vctwo);

  303. 

  304.         pixelssum3 = vec_add(pixelssum4, vctwo);

  305.         pixelssum1 = vec_add(pixelssum2, vctwo);

  306. 

  307.         blockv = vec_packsu(temp3, temp4);

  308. 

  309.         vec_st(blockv, 0, block);

  310. 

  311.         block += line_size;

  312.         pixels += line_size;

  313.     }

  314. }

  315. 

  316. /* next one assumes that ((line_size % 16) == 0) */

  317. static void put_no_rnd_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, ptrdiff_t line_size, int h)

  318. {

  319.     register int i;

  320.     register vector unsigned char pixelsv1, pixelsv2, pixelsv3, pixelsv4;

  321.     register vector unsigned char blockv, temp1, temp2;

  322.     register vector unsigned short temp3, temp4,

  323.         pixelssum1, pixelssum2, pixelssum3, pixelssum4;

  324.     register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);

  325.     register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1);

  326.     register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);

  327. 

  328.     temp1 = vec_ld(0, pixels);

  329.     temp2 = vec_ld(16, pixels);

  330.     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));

  331.     if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F) {

  332.         pixelsv2 = temp2;

  333.     } else {

  334.         pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));

  335.     }

  336.     pixelsv3 = vec_mergel(vczero, pixelsv1);

  337.     pixelsv4 = vec_mergel(vczero, pixelsv2);

  338.     pixelsv1 = vec_mergeh(vczero, pixelsv1);

  339.     pixelsv2 = vec_mergeh(vczero, pixelsv2);

  340.     pixelssum3 = vec_add((vector unsigned short)pixelsv3,

  341.                          (vector unsigned short)pixelsv4);

  342.     pixelssum3 = vec_add(pixelssum3, vcone);

  343.     pixelssum1 = vec_add((vector unsigned short)pixelsv1,

  344.                          (vector unsigned short)pixelsv2);

  345.     pixelssum1 = vec_add(pixelssum1, vcone);

  346. 

  347.     for (i = 0; i < h ; i++) {

  348.         blockv = vec_ld(0, block);

  349. 

  350.         temp1 = vec_ld(line_size, pixels);

  351.         temp2 = vec_ld(line_size + 16, pixels);

  352.         pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));

  353.         if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F) {

  354.             pixelsv2 = temp2;

  355.         } else {

  356.             pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));

  357.         }

  358. 

  359.         pixelsv3 = vec_mergel(vczero, pixelsv1);

  360.         pixelsv4 = vec_mergel(vczero, pixelsv2);

  361.         pixelsv1 = vec_mergeh(vczero, pixelsv1);

  362.         pixelsv2 = vec_mergeh(vczero, pixelsv2);

  363. 

  364.         pixelssum4 = vec_add((vector unsigned short)pixelsv3,

  365.                              (vector unsigned short)pixelsv4);

  366.         pixelssum2 = vec_add((vector unsigned short)pixelsv1,

  367.                              (vector unsigned short)pixelsv2);

  368.         temp4 = vec_add(pixelssum3, pixelssum4);

  369.         temp4 = vec_sra(temp4, vctwo);

  370.         temp3 = vec_add(pixelssum1, pixelssum2);

  371.         temp3 = vec_sra(temp3, vctwo);

  372. 

  373.         pixelssum3 = vec_add(pixelssum4, vcone);

  374.         pixelssum1 = vec_add(pixelssum2, vcone);

  375. 

  376.         blockv = vec_packsu(temp3, temp4);

  377. 

  378.         vec_st(blockv, 0, block);

  379. 

  380.         block += line_size;

  381.         pixels += line_size;

  382.     }

  383. }

  384. 

  385. /* next one assumes that ((line_size % 8) == 0) */

  386. static void avg_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)

  387. {

  388.     register int i;

  389.     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;

  390.     register vector unsigned char blockv, temp1, temp2, blocktemp;

  391.     register vector unsigned short pixelssum1, pixelssum2, temp3;

  392. 

  393.     register const vector unsigned char vczero = (const vector unsigned char)

  394.                                         vec_splat_u8(0);

  395.     register const vector unsigned short vctwo = (const vector unsigned short)

  396.                                         vec_splat_u16(2);

  397. 

  398.     temp1 = vec_ld(0, pixels);

  399.     temp2 = vec_ld(16, pixels);

  400.     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));

  401.     if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F) {

  402.         pixelsv2 = temp2;

  403.     } else {

  404.         pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));

  405.     }

  406.     pixelsv1 = vec_mergeh(vczero, pixelsv1);

  407.     pixelsv2 = vec_mergeh(vczero, pixelsv2);

  408.     pixelssum1 = vec_add((vector unsigned short)pixelsv1,

  409.                          (vector unsigned short)pixelsv2);

  410.     pixelssum1 = vec_add(pixelssum1, vctwo);

  411. 

  412.     for (i = 0; i < h ; i++) {

  413.         int rightside = ((unsigned long)block & 0x0000000F);

  414.         blockv = vec_ld(0, block);

  415. 

  416.         temp1 = vec_ld(line_size, pixels);

  417.         temp2 = vec_ld(line_size + 16, pixels);

  418.         pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));

  419.         if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F) {

  420.             pixelsv2 = temp2;

  421.         } else {

  422.             pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));

  423.         }

  424. 

  425.         pixelsv1 = vec_mergeh(vczero, pixelsv1);

  426.         pixelsv2 = vec_mergeh(vczero, pixelsv2);

  427.         pixelssum2 = vec_add((vector unsigned short)pixelsv1,

  428.                              (vector unsigned short)pixelsv2);

  429.         temp3 = vec_add(pixelssum1, pixelssum2);

  430.         temp3 = vec_sra(temp3, vctwo);

  431.         pixelssum1 = vec_add(pixelssum2, vctwo);

  432.         pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero);

  433. 

  434.         if (rightside) {

  435.             blocktemp = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1));

  436.         } else {

  437.             blocktemp = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3));

  438.         }

  439. 

  440.         blockv = vec_avg(blocktemp, blockv);

  441.         vec_st(blockv, 0, block);

  442. 

  443.         block += line_size;

  444.         pixels += line_size;

  445.     }

  446. }

  447. #endif /* HAVE_ALTIVEC */

  448. 

  449. av_cold void ff_hpeldsp_init_ppc(HpelDSPContext *c, int flags)

  450. {

  451. #if HAVE_ALTIVEC

  452.     if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))

  453.         return;

  454. 

  455.     c->avg_pixels_tab[0][0]        = ff_avg_pixels16_altivec;

  456.     c->avg_pixels_tab[1][0]        = avg_pixels8_altivec;

  457.     c->avg_pixels_tab[1][3]        = avg_pixels8_xy2_altivec;

  458. 

  459.     c->put_pixels_tab[0][0]        = ff_put_pixels16_altivec;

  460.     c->put_pixels_tab[1][3]        = put_pixels8_xy2_altivec;

  461.     c->put_pixels_tab[0][3]        = put_pixels16_xy2_altivec;

  462. 

  463.     c->put_no_rnd_pixels_tab[0][0] = ff_put_pixels16_altivec;

  464.     c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels8_xy2_altivec;

  465.     c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_altivec;

  466. #endif /* HAVE_ALTIVEC */

  467. }