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.
49674 Commits
32 Branches
1.0GB
Tree: b5884db437
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b5884db437'
${ noResults }
FFmpeg/libavcodec/bfin/pixels_bfin.S

740 lines
24KB
Raw Blame History 

  1. /*

  2.  * Blackfin Pixel Operations

  3.  * Copyright (C) 2007 Marc Hoffman <marc.hoffman@analog.com>

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

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

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

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

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

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

  18.  * License along with FFmpeg; if not, write to the Free Software

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

  20.  */

  21. #include "config_bfin.h"

  22. 

  23. DEFUN(put_pixels_clamped,mL1,

  24.         (int16_t *block, uint8_t *dest, int line_size)):

  25.     [--SP] = (R7:4);

  26.     R4 = 0;

  27.     R5.l = 0x00ff;

  28.     R5.h = 0x00ff;

  29.     I0 = R0;         // block

  30.     I1 = R1;         // dest

  31.     R2 += -4;        // line_size

  32.     M1 = R2;

  33.     P0 = 8;

  34.     R0 = [I0++];

  35.     R1 = [I0++];

  36.     R2 = MAX(R0, R4) (V);

  37.     LSETUP (ppc$0,ppc$1) LC0=P0;

  38. ppc$0: R2 = MIN(R2, R5) (V);

  39.        R3 = MAX(R1, R4) (V);

  40.        R3 = MIN(R3, R5) (V)      || R0 = [I0++];

  41.        R6 = BYTEPACK (R2,R3)     || R1 = [I0++];

  42.        R2 = MAX(R0, R4) (V)      || [I1++] = R6;

  43.        R2 = MIN(R2, R5) (V);

  44.        R3 = MAX(R1, R4) (V);

  45.        R3 = MIN(R3, R5) (V)      || R0 = [I0++];

  46.        R6 = BYTEPACK (R2,R3)     || R1 = [I0++];

  47. ppc$1: R2 = Max(R0, R4) (V)      || [I1++M1] = R6;

  48. 

  49.     (R7:4) = [SP++];

  50.     RTS;

  51. DEFUN_END(put_pixels_clamped)

  52. 

  53. DEFUN(add_pixels_clamped,mL1,

  54.         (int16_t *block, uint8_t *dest, int line_size)):

  55.     [-- SP] = (R7:4);

  56.     R4 = 0;

  57.     I0 = 0;

  58.     R2 += -4;        // line_size

  59.     M0 = R2;

  60.     I1 = R1;         // dest

  61.     I3 = R0;         // block

  62.     I2 = R1;         // dest

  63.     P0 = 8;

  64.     M3 = 2;

  65.     R0 = [I3++]  || R2 = [I1];

  66.     R2 = R2 << 8                      || R0.H = W[I3--]  || R3 = [I1++];

  67.     R3 = R3 >> 8                      || R1.L = W[I3]    || I3 += 4;

  68.     R6 = BYTEOP3P(R1:0, R3:2) (LO)    || R1.H = W[I3++]  || R2 = [I1];

  69. 

  70.     LSETUP(apc$2,apc$3) LC1 = P0;

  71. apc$2: R7 = BYTEOP3P(R1:0, R3:2) (HI, R) || R0 = [I3++]     || R3 = [I1++M0];

  72.        R2 = R2 << 8                      || R0.H = W[I3--];

  73.        R3 = R3 >> 8                      || R1.L = W[I3]    || I3 += 4;

  74.        R6 = R6 + R7 (S)                  || R1.H = W[I3];

  75.        R6 = BYTEOP3P(R1:0, R3:2) (LO)    || I3+=M3          || [I2++]=R6;

  76.        R7 = BYTEOP3P(R1:0, R3:2) (HI, R) || R0 = [I3++]     || R2 = [I1];

  77.        R2 = R2 << 8                      || R0.H = W[I3--]  || R3 = [I1++];

  78.        R3 = R3 >> 8                      || R1.L = W[I3]    || I3 += 4;

  79.        R6 = R6 + R7 (S)                  || R1.H = W[I3++];

  80. apc$3: R6 = BYTEOP3P(R1:0, R3:2) (LO)    || [I2++M0] = R6   || R2 = [I1];

  81. 

  82.     (R7:4) = [SP++];

  83.     RTS;

  84. DEFUN_END(add_pixels_clamped)

  85. 

  86. 

  87. /**

  88.   motion compensation

  89.   primitives

  90. 

  91.      * Halfpel motion compensation with rounding (a+b+1)>>1.

  92.      * This is an array[4][4] of motion compensation funcions for 4

  93.      * horizontal blocksizes (8,16) and the 4 halfpel positions<br>

  94.      * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]

  95.      * @param block destination where the result is stored

  96.      * @param pixels source

  97.      * @param line_size number of bytes in a horizontal line of block

  98.      * @param h height

  99. 

  100. */

  101. 

  102. DEFUN(put_pixels8uc,mL1,

  103.         (uint8_t *block, const uint8_t *s0, const uint8_t *s1,

  104.                  int dest_size, int line_size, int h)):

  105.         i3=r0;        // dest

  106.         i0=r1;        // src0

  107.         i1=r2;        // src1

  108.         r0=[sp+12];   // dest_size

  109.         r2=[sp+16];   // line_size

  110.         p0=[sp+20];   // h

  111.         [--sp] = (r7:6);

  112.         r0+=-4;

  113.         m3=r0;

  114.         r2+=-8;

  115.         m0=r2;

  116.         LSETUP(pp8$0,pp8$1) LC0=P0;

  117.         DISALGNEXCPT                || R0 = [I0++]  || R2  =[I1++];

  118. 

  119. pp8$0:  DISALGNEXCPT                || R1 = [I0++]  || R3  =[I1++];

  120.         R6 = BYTEOP1P(R1:0,R3:2)    || R0 = [I0++M0]|| R2  =[I1++M0];

  121.         R7 = BYTEOP1P(R1:0,R3:2)(R) || R0 = [I0++]  || [I3++] = R6 ;

  122. pp8$1:  DISALGNEXCPT                || R2 = [I1++]  || [I3++M3] = R7;

  123. 

  124.         (r7:6) = [sp++];

  125.         RTS;

  126. DEFUN_END(put_pixels8uc)

  127. 

  128. DEFUN(put_pixels16uc,mL1,

  129.         (uint8_t *block, const uint8_t *s0, const uint8_t *s1,

  130.                  int dest_size, int line_size, int h)):

  131.         link 0;

  132.         [--sp] = (r7:6);

  133.         i3=r0;        // dest

  134.         i0=r1;        // src0

  135.         i1=r2;        // src1

  136.         r0=[fp+20];   // dest_size

  137.         r2=[fp+24];   // line_size

  138.         p0=[fp+28];   // h

  139. 

  140. 

  141.         r0+=-12;

  142.         m3=r0;        // line_size

  143.         r2+=-16;

  144.         m0=r2;

  145. 

  146.         LSETUP(pp16$0,pp16$1) LC0=P0;

  147.          DISALGNEXCPT                || R0 = [I0++]   || R2  =[I1++];

  148. 

  149. pp16$0:  DISALGNEXCPT                || R1 = [I0++]   || R3  =[I1++];

  150.          R6 = BYTEOP1P(R1:0,R3:2)    || R0 = [I0++]   || R2  =[I1++];

  151.          R7 = BYTEOP1P(R1:0,R3:2)(R) || R1 = [I0++]   || R3  =[I1++];

  152.          [I3++] = R6;

  153.          R6 = BYTEOP1P(R1:0,R3:2)    || R0 = [I0++M0] || R2  =[I1++M0];

  154.          R7 = BYTEOP1P(R1:0,R3:2)(R) || R0 = [I0++]   || [I3++] = R7 ;

  155.          [I3++] = R6;

  156. pp16$1:  DISALGNEXCPT                || R2 = [I1++]   || [I3++M3] = R7;

  157. 

  158.         (r7:6) = [sp++];

  159.         unlink;

  160.         RTS;

  161. DEFUN_END(put_pixels16uc)

  162. 

  163. 

  164. 

  165. 

  166. 

  167. 

  168. DEFUN(put_pixels8uc_nornd,mL1,

  169.         (uint8_t *block, const uint8_t *s0, const uint8_t *s1,

  170.                  int line_size, int h)):

  171.         i3=r0;        // dest

  172.         i0=r1;        // src0

  173.         i1=r2;        // src1

  174.         r2=[sp+12];   // line_size

  175.         p0=[sp+16];   // h

  176.         [--sp] = (r7:6);

  177.         r2+=-4;

  178.         m3=r2;

  179.         r2+=-4;

  180.         m0=r2;

  181.         LSETUP(pp8$2,pp8$3) LC0=P0;

  182.         DISALGNEXCPT                || R0 = [I0++]  || R2  =[I1++];

  183. 

  184. pp8$2:  DISALGNEXCPT                || R1 = [I0++]  || R3  =[I1++];

  185.         R6 = BYTEOP1P(R1:0,R3:2)(T)  || R0 = [I0++M0]|| R2  =[I1++M0];

  186.         R7 = BYTEOP1P(R1:0,R3:2)(T,R) || R0 = [I0++]  || [I3++] = R6 ;

  187. pp8$3:  DISALGNEXCPT                || R2 = [I1++]  || [I3++M3] = R7;

  188. 

  189.         (r7:6) = [sp++];

  190.         RTS;

  191. DEFUN_END(put_pixels8uc_nornd)

  192. 

  193. DEFUN(put_pixels16uc_nornd,mL1,

  194.         (uint8_t *block, const uint8_t *s0, const uint8_t *s1,

  195.                  int line_size, int h)):

  196.         i3=r0;        // dest

  197.         i0=r1;        // src0

  198.         i1=r2;        // src1

  199.         r2=[sp+12];   // line_size

  200.         p0=[sp+16];   // h

  201. 

  202.         [--sp] = (r7:6);

  203.         r2+=-12;

  204.         m3=r2;        // line_size

  205.         r2+=-4;

  206.         m0=r2;

  207. 

  208.         LSETUP(pp16$2,pp16$3) LC0=P0;

  209.         DISALGNEXCPT                || R0 = [I0++]   || R2  =[I1++];

  210. 

  211. pp16$2:

  212.         DISALGNEXCPT                || R1 = [I0++]   || R3  =[I1++];

  213.         R6 = BYTEOP1P(R1:0,R3:2)(T)    || R0 = [I0++]   || R2  =[I1++];

  214.         R7 = BYTEOP1P(R1:0,R3:2)(T,R) || R1 = [I0++]   || R3  =[I1++];

  215.         [I3++] = R6;

  216. 

  217.         R6 = BYTEOP1P(R1:0,R3:2)(T)    || R0 = [I0++M0] || R2  =[I1++M0];

  218.         R7 = BYTEOP1P(R1:0,R3:2)(T,R) || R0 = [I0++]   || [I3++] = R7 ;

  219.         [I3++] = R6;

  220. pp16$3: DISALGNEXCPT                || R2 = [I1++]   || [I3++M3] = R7;

  221. 

  222.         (r7:6) = [sp++];

  223. 

  224.         RTS;

  225. DEFUN_END(put_pixels16uc_nornd)

  226. 

  227. DEFUN(z_put_pixels16_xy2,mL1,

  228.         (uint8_t *block, const uint8_t *s0,

  229.                  int dest_size, int line_size, int h)):

  230.         link 0;

  231.         [--sp] = (r7:4);

  232.         i3=r0;        // dest

  233.         i0=r1;        // src0--> pixels

  234.         i1=r1;        // src1--> pixels + line_size

  235.         r2+=-12;

  236.         m2=r2;        // m2=dest_width-4

  237.         r2=[fp+20];

  238.         m3=r2;        // line_size

  239.         p0=[fp+24];   // h

  240.         r2+=-16;

  241.         i1+=m3;       /* src1 + line_size */

  242.         m0=r2;        /* line-size - 20 */

  243. 

  244.         B0 = I0;

  245.         B1 = I1;

  246.         B3 = I3;

  247. 

  248.         DISALGNEXCPT                       || R0 = [I0++] || R2  =[I1++];

  249. 

  250.         LSETUP(LS$16E,LE$16E) LC0=P0;

  251. LS$16E: DISALGNEXCPT                       || R1 = [I0++] || R3  =[I1++];

  252.         R4 = BYTEOP2P (R3:2,R1:0) (RNDL)   || R0 = [I0++] || R2  =[I1++];

  253.         R5 = BYTEOP2P (R3:2,R1:0) (RNDL,R) || R1 = [I0++] || [I3++] = R4 ;

  254.         DISALGNEXCPT                       || R3 = [I1++] || [I3++] = R5;

  255.         R4 = BYTEOP2P (R3:2,R1:0) (RNDL)   || R0 = [I0++M0]|| R2  = [I1++M0];

  256.         R5 = BYTEOP2P (R3:2,R1:0) (RNDL,R) || R0 = [I0++] || [I3++] = R4 ;

  257. LE$16E: DISALGNEXCPT                       || R2 = [I1++] || [I3++M2] = R5;

  258. 

  259.         M1 = 1;

  260.         I3 = B3;

  261.         I1 = B1;

  262.         I0 = B0;

  263. 

  264.         I0 += M1;

  265.         I1 += M1;

  266. 

  267.         DISALGNEXCPT                       || R0 = [I0++] || R2  =[I1++];

  268.         LSETUP(LS$16O,LE$16O) LC0=P0;

  269. LS$16O: DISALGNEXCPT                       || R1 = [I0++] || R3  =[I1++];

  270.         R4 = BYTEOP2P (R3:2,R1:0) (RNDH)   || R0 = [I0++] || R2  =[I1++];

  271.         R5 = BYTEOP2P (R3:2,R1:0) (RNDH,R) || R1 = [I0++] || R6  =[I3++];

  272.         R4 = R4 +|+ R6                       || R7 = [I3--];

  273.         R5 = R5 +|+ R7                       || [I3++] = R4;

  274.         DISALGNEXCPT                       || R3  =[I1++] || [I3++] = R5;

  275.         R4 = BYTEOP2P (R3:2,R1:0) (RNDH)   || R0 = [I0++M0]|| R2  = [I1++M0];

  276.         R5 = BYTEOP2P (R3:2,R1:0) (RNDH,R) || R0 = [I0++] || R6 = [I3++];

  277.         R4 = R4 +|+ R6                       || R7 = [I3--];

  278.         R5 = R5 +|+ R7                       || [I3++] = R4;

  279. LE$16O: DISALGNEXCPT                       || R2 = [I1++] || [I3++M2] = R5;

  280. 

  281.         (r7:4) = [sp++];

  282.         unlink;

  283.         rts;

  284. DEFUN_END(z_put_pixels16_xy2)

  285. 

  286. DEFUN(put_pixels16_xy2_nornd,mL1,

  287.         (uint8_t *block, const uint8_t *s0,

  288.                  int line_size, int h)):

  289.         link 0;

  290.         [--sp] = (r7:4);

  291.         i3=r0;        // dest

  292.         i0=r1;        // src0--> pixels

  293.         i1=r1;        // src1--> pixels + line_size

  294.         m3=r2;

  295.         r2+=-12;

  296.         m2=r2;

  297.         r2+=-4;

  298.         i1+=m3;       /* src1 + line_size */

  299.         m0=r2;        /* line-size - 20 */

  300.         p0=[fp+20];   // h

  301. 

  302.         B0=I0;

  303.         B1=I1;

  304.         B3=I3;

  305. 

  306.         DISALGNEXCPT                       || R0 = [I0++] || R2  =[I1++];

  307. 

  308.         LSETUP(LS$16ET,LE$16ET) LC0=P0;

  309. LS$16ET:DISALGNEXCPT                       || R1 = [I0++] || R3  =[I1++];

  310.         R4 = BYTEOP2P (R3:2,R1:0) (TL)     || R0 = [I0++] || R2  =[I1++];

  311.         R5 = BYTEOP2P (R3:2,R1:0) (TL,R)   || R1 = [I0++] || [I3++] = R4 ;

  312.         DISALGNEXCPT                       || R3 = [I1++] || [I3++] = R5;

  313.         R4 = BYTEOP2P (R3:2,R1:0) (TL)     || R0 = [I0++M0]|| R2  = [I1++M0];

  314.         R5 = BYTEOP2P (R3:2,R1:0) (TL,R)   || R0 = [I0++] || [I3++] = R4 ;

  315. LE$16ET:DISALGNEXCPT                       || R2 = [I1++] || [I3++M2] = R5;

  316. 

  317.         M1 = 1;

  318.         I3=B3;

  319.         I1=B1;

  320.         I0=B0;

  321. 

  322.         I0 += M1;

  323.         I1 += M1;

  324. 

  325.         DISALGNEXCPT                       || R0 = [I0++] || R2  =[I1++];

  326.         LSETUP(LS$16OT,LE$16OT) LC0=P0;

  327. LS$16OT:DISALGNEXCPT                       || R1 = [I0++] || R3  =[I1++];

  328.         R4 = BYTEOP2P (R3:2,R1:0) (TH)     || R0 = [I0++] || R2  =[I1++];

  329.         R5 = BYTEOP2P (R3:2,R1:0) (TH,R)   || R1 = [I0++] || R6  =[I3++];

  330.         R4 = R4 +|+ R6                                    || R7 = [I3--];

  331.         R5 = R5 +|+ R7                                    || [I3++] = R4;

  332.         DISALGNEXCPT                       || R3  =[I1++] || [I3++] = R5;

  333.         R4 = BYTEOP2P (R3:2,R1:0) (TH)     || R0 = [I0++M0]|| R2  = [I1++M0];

  334.         R5 = BYTEOP2P (R3:2,R1:0) (TH,R)   || R0 = [I0++] || R6 = [I3++];

  335.         R4 = R4 +|+ R6                                    || R7 = [I3--];

  336.         R5 = R5 +|+ R7                                    || [I3++] = R4;

  337. LE$16OT:DISALGNEXCPT                       || R2 = [I1++] || [I3++M2] = R5;

  338. 

  339.         (r7:4) = [sp++];

  340.         unlink;

  341.         rts;

  342. DEFUN_END(put_pixels16_xy2_nornd)

  343. 

  344. DEFUN(z_put_pixels8_xy2,mL1,

  345.         (uint8_t *block, const uint8_t *s0,

  346.                  int dest_size, int line_size, int h)):

  347.         link 0;

  348.         [--sp] = (r7:4);

  349.         i3=r0;        // dest

  350.         i0=r1;        // src0--> pixels

  351.         i1=r1;        // src1--> pixels + line_size

  352.         r2+=-4;

  353.         m2=r2;        // m2=dest_width-4

  354.         r2=[fp+20];

  355.         m3=r2;        // line_size

  356.         p0=[fp+24];   // h

  357.         r2+=-8;

  358.         i1+=m3;       /* src1 + line_size */

  359.         m0=r2;        /* line-size - 20 */

  360. 

  361.         b0 = I0;

  362.         b1 = I1;

  363.         b3 = I3;

  364. 

  365.         LSETUP(LS$8E,LE$8E) LC0=P0;

  366.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  367. LS$8E:  DISALGNEXCPT                       || R1 = [I0++]   || R3  =[I1++];

  368.         R4 = BYTEOP2P (R3:2,R1:0) (RNDL)   || R0 = [I0++M0] || R2  =[I1++M0];

  369.         R5 = BYTEOP2P (R3:2,R1:0) (RNDL,R) || R0 = [I0++]   || [I3++] = R4 ;

  370. LE$8E:  DISALGNEXCPT                       || R2 = [I1++]   || [I3++M2] = R5;

  371. 

  372.         M1 = 1;

  373.         I3 = b3;

  374.         I1 = b1;

  375.         I0 = b0;

  376. 

  377.         I0 += M1;

  378.         I1 += M1;

  379. 

  380.         LSETUP(LS$8O,LE$8O) LC0=P0;

  381.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  382. LS$8O:  DISALGNEXCPT                       || R1 = [I0++]   || R3  =[I1++];

  383.         R4 = BYTEOP2P (R3:2,R1:0) (RNDH)   || R0 = [I0++M0] || R2  =[I1++M0];

  384.         R5 = BYTEOP2P (R3:2,R1:0) (RNDH,R) || R0 = [I0++]   || R6  =[I3++];

  385.         R4 = R4 +|+ R6                                      || R7 = [I3--];

  386.         R5 = R5 +|+ R7                                      || [I3++] = R4;

  387. LE$8O:  DISALGNEXCPT                       || R2  =[I1++]   || [I3++M2] = R5;

  388. 

  389.         (r7:4) = [sp++];

  390.         unlink;

  391.         rts;

  392. DEFUN_END(z_put_pixels8_xy2)

  393. 

  394. DEFUN(put_pixels8_xy2_nornd,mL1,

  395.         (uint8_t *block, const uint8_t *s0, int line_size, int h)):

  396.         link 0;

  397.         [--sp] = (r7:4);

  398.         i3=r0;        // dest

  399.         i0=r1;        // src0--> pixels

  400.         i1=r1;        // src1--> pixels + line_size

  401.         m3=r2;

  402.         r2+=-4;

  403.         m2=r2;

  404.         r2+=-4;

  405.         i1+=m3;       /* src1 + line_size */

  406.         m0=r2;        /* line-size - 20 */

  407.         p0=[fp+20];   // h

  408. 

  409. 

  410.         b0 = I0;

  411.         b1 = I1;

  412.         b3 = I3;

  413. 

  414.         LSETUP(LS$8ET,LE$8ET) LC0=P0;

  415.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  416. 

  417. LS$8ET: DISALGNEXCPT                       || R1 = [I0++]   || R3 = [I1++];

  418.         R4 = BYTEOP2P (R3:2,R1:0) (TL)     || R0 = [I0++M0] || R2 = [I1++M0];

  419.         R5 = BYTEOP2P (R3:2,R1:0) (TL,R)   || R0 = [I0++]   || [I3++] = R4 ;

  420. LE$8ET: DISALGNEXCPT                       || R2 = [I1++]   || [I3++M2] = R5;

  421. 

  422.         M1 = 1;

  423.         I3 = b3;

  424.         I1 = b1;

  425.         I0 = b0;

  426. 

  427.         I0 += M1;

  428.         I1 += M1;

  429. 

  430.         LSETUP(LS$8OT,LE$8OT) LC0=P0;

  431.         DISALGNEXCPT                       || R0 = [I0++]   || R2 = [I1++];

  432. 

  433. LS$8OT: DISALGNEXCPT                       || R1 = [I0++]   || R3 = [I1++];

  434.         R4 = BYTEOP2P (R3:2,R1:0) (TH)     || R0 = [I0++M0] || R2 = [I1++M0];

  435.         R5 = BYTEOP2P (R3:2,R1:0) (TH,R)   || R0 = [I0++]   || R6 = [I3++];

  436.         R4 = R4 +|+ R6                                      || R7 = [I3--];

  437.         R5 = R5 +|+ R7                                      || [I3++] = R4;

  438. LE$8OT: DISALGNEXCPT                       || R2  =[I1++]   || [I3++M2] = R5;

  439. 

  440.         (r7:4) = [sp++];

  441.         unlink;

  442.         rts;

  443. 

  444. DEFUN(diff_pixels,mL1,

  445.        (int16_t *block, uint8_t *s1, uint8_t *s2, int stride)):

  446.         link 0;

  447.         [--sp] = (r7:4);

  448.         p0=8;

  449.         i3=r0;        // block

  450.         i0=r1;        // s1

  451.         i1=r2;        // s2

  452.         r2=[fp+20];   // stride

  453.         r2+=-8;

  454.         m0=r2;

  455. 

  456. 

  457.         LSETUP(.LS0,.LE0) LC0=P0;

  458.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  459. 

  460. .LS0:   DISALGNEXCPT                       || R1 = [I0++]   || R3 = [I1++];

  461.         (R5,R4) = BYTEOP16M (R1:0,R3:2)    || R0 = [I0++M0] || R2 = [I1++M0];

  462.         (R7,R6) = BYTEOP16M (R1:0,R3:2) (R)|| R0 = [I0++]   || [I3++] = R4;

  463.         DISALGNEXCPT                       || R2 = [I1++]   || [I3++] = R5;

  464.         [i3++]=r6;

  465. .LE0:  [i3++]=r7;

  466. 

  467.         (r7:4) = [sp++];

  468.         unlink;

  469.         rts;

  470. DEFUN_END(put_pixels8_xy2_nornd)

  471. 

  472. /*

  473.     for (i = 0; i < 16; i++) {

  474.         for (j = 0; j < 16; j++) {

  475.           sum += pix[j];

  476.         }

  477.         pix += line_size;

  478.     }

  479. */

  480. DEFUN(pix_sum,mL1,

  481.         (uint8_t *p, int stride)):

  482.         link 0;

  483.         [--sp] = (r7:4);

  484.         p0=8;

  485.         i0=r0;        // s1

  486.         i1=r0;

  487.         m1=r1;

  488.         r1=r1+r1;

  489.         r1+=-16;       // stride

  490.         m0=r1;

  491.         i1+=m1;

  492. 

  493.         r6=0;

  494. 

  495.         LSETUP(LS$PS,LE$PS) LC0=P0;

  496.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  497. 

  498. LS$PS:  DISALGNEXCPT                       || R1 = [I0++]   || R3 = [I1++];

  499.         (R5,R4) = BYTEOP16P (R3:2,R1:0)    || R0 = [I0++]   || R2 = [I1++];

  500.         r6=r6+|+r5;

  501.         r6=r6+|+r4;

  502.         (R5,R4) = BYTEOP16P (R3:2,R1:0) (R)|| R1 = [I0++]   || R3 = [I1++];

  503.         r6=r6+|+r5;

  504.         r6=r6+|+r4;

  505.         (R5,R4) = BYTEOP16P (R3:2,R1:0)    || R0 = [I0++m0] || R2 = [I1++m0];

  506.         r6=r6+|+r5;

  507.         r6=r6+|+r4;

  508.         (R5,R4) = BYTEOP16P (R3:2,R1:0) (R)|| R0 = [I0++]   || R2 = [I1++];

  509.         r6=r6+|+r5;

  510. LE$PS:  r6=r6+|+r4;

  511.         r0.l=r6.l+r6.h;

  512.         r0.h=0;

  513. 

  514.         (r7:4) = [sp++];

  515.         unlink;

  516.         rts;

  517. DEFUN_END(pix_sum)

  518. 

  519. 

  520. DEFUN(get_pixels,mL1,

  521.         (int16_t *av_restrict block, const uint8_t *pixels, int line_size)):

  522.         [--sp] = (r7:4);

  523.         i3=r0;        // dest

  524.         i0=r1;        // src0

  525.         p0=8;

  526.         r2+=-8;

  527.         m0=r2;

  528.         LSETUP(gp8$0,gp8$1) LC0=P0;

  529. 

  530.         DISALGNEXCPT                   || R0 = [I0++];

  531.         DISALGNEXCPT                   || R1 = [I0++];

  532. 

  533. gp8$0:  (R7,R6) = byteunpack R1:0      || R0 = [I0++M0];

  534.         (R5,R4) = byteunpack R1:0 (R)  || R0 = [I0++]    || [I3++]=R6;

  535.         DISALGNEXCPT                   || R1 = [I0++]    || [I3++]=R7;

  536.         [I3++]=R4;

  537. gp8$1:  [I3++]=R5

  538. 

  539. 

  540.         (r7:4) = [sp++];

  541.         RTS;

  542. DEFUN_END(get_pixels)

  543. 

  544. 

  545. /* sad = sad16x16 (ubyte *mb, ubyte *refwin, srcwidth, refwinwidth, h) */

  546. /* 91 cycles */

  547. DEFUN(z_sad16x16,mL1,

  548.         (uint8_t *blk1, uint8_t *blk2, int dsz, int line_size, int h)):

  549.         link 0;

  550.         I0 = R0;

  551.         I1 = R1;

  552. 

  553.         A1 = A0 = 0;

  554.         R0 = [sp+20]; // rwidth

  555.         P2 = [sp+24]; // height

  556.         R3 = 16;

  557.         R0 = R0 - R3;

  558.         R3 = R2 - R3;

  559.         M1 = R0;

  560.         M0 = R3;

  561. 

  562.         DISALGNEXCPT         || R0 = [I0++]    || R2 = [I1++];

  563.         LSETUP (s$16, e$16) LC0=P2;

  564. s$16:   DISALGNEXCPT         || R1 = [I0++]    || R3 = [I1++];

  565.         SAA (R1:0,R3:2)      || R0 = [I0++]    || R2 = [I1++];

  566.         SAA (R1:0,R3:2) (R)  || R1 = [I0++]    || R3 = [I1++];

  567.         SAA (R1:0,R3:2)      || R0 = [I0++M0]  || R2 = [I1++M1];

  568. e$16:   SAA (R1:0,R3:2) (R)  || R0 = [I0++]    || R2 = [I1++];

  569. 

  570.         R3=A1.L+A1.H,  R2=A0.L+A0.H ;

  571.         R0 = R2 + R3 ;

  572.         unlink;

  573.         RTS;

  574. DEFUN_END(z_sad16x16)

  575. 

  576. /* sad = sad8x8 (ubyte *mb, ubyte *refwin, int srcwidth, int refwinwidth, int h) */

  577. /* 36 cycles */

  578. DEFUN(z_sad8x8,mL1,

  579.         (uint8_t *blk1, uint8_t *blk2, int dsz, int line_size, int h)):

  580.         I0 = R0;

  581.         I1 = R1;

  582. 

  583.         A1 = A0 = 0;

  584.         r0 = [sp+12]; // rwidth

  585.         P2 = [sp+16]; //height

  586.         R3 = 8;

  587.         R0 = R0 - R3;

  588.         R3 = R2 - R3;

  589.         M0 = R3;

  590.         M1 = R0;

  591. 

  592.         LSETUP (s$8, e$8) LC0=P2;

  593.         DISALGNEXCPT         || R0 = [I0++]   || R2 = [I1++];

  594.         DISALGNEXCPT         || R1 = [I0++]   || R3 = [I1++];

  595. s$8:    SAA (R1:0,R3:2)      || R0 = [I0++M0] || R2 = [I1++M1];

  596.         SAA (R1:0,R3:2) (R)  || R0 = [I0++]   || R2 = [I1++];

  597. e$8:    DISALGNEXCPT         || R1 = [I0++]   || R3 = [I1++];

  598. 

  599.         R3=A1.L+A1.H,  R2=A0.L+A0.H ;

  600.         R0 = R2 + R3 ;

  601.         RTS;

  602. DEFUN_END(z_sad8x8)

  603. 

  604. DEFUN(pix_norm1,mL1,

  605.         (uint8_t * pix, int line_size)):

  606.         [--SP]=(R7:4,P5:3);

  607. 

  608.         // Fetch the input arguments.

  609.         P1 = R0;  // pix

  610.         P0 = R1;  // line_size

  611.         P5 = 16;  // loop ctr.

  612.         P0 -= P5;

  613.         M0 = P0;  // M0 = line_size-16;

  614.         // Now for the real work.

  615.         A1 = A0 = 0;

  616.         lsetup(_pix_norm1_blkfn_loopStart, _pix_norm1_blkfn_loopEnd) LC1 = P5;

  617.         I0 = P1;

  618.         DISALGNEXCPT || r0 = [i0++];

  619. 

  620. _pix_norm1_blkfn_loopStart:

  621.         // following unpacks pix1[0..15] pix1+line_size[0..15]

  622.         DISALGNEXCPT || r1 = [i0++];

  623. 

  624.         (r5, r4) = byteunpack r1:0 || r0 = [i0++];

  625.         a1 += r5.h * r5.h, a0 += r5.l * r5.l (is);

  626.         a1 += r4.h * r4.h, a0 += r4.l * r4.l (is);

  627.         (r5, r4) = byteunpack r1:0(r) || r1 = [i0++];

  628.         a1 += r5.h * r5.h, a0 += r5.l * r5.l (is);

  629.         a1 += r4.h * r4.h, a0 += r4.l * r4.l (is);

  630.         (r5, r4) = byteunpack r1:0 || r0 = [i0++M0];

  631.         a1 += r5.h * r5.h, a0 += r5.l * r5.l (is);

  632.         a1 += r4.h * r4.h, a0 += r4.l * r4.l (is);

  633.         (r5, r4) = byteunpack r1:0(r) || r0 = [i0++];

  634.         a1 += r5.h * r5.h, a0 += r5.l * r5.l (is);

  635. _pix_norm1_blkfn_loopEnd:

  636.         a1 += r4.h * r4.h, a0 += r4.l * r4.l (is);

  637. 

  638. 

  639. // Clean up at the end:

  640.         R2 = A0, R3 = A1;

  641.         R0 = R2 + R3 (S);

  642. 

  643.         (R7:4,P5:3)=[SP++];

  644. 

  645.         RTS;

  646. DEFUN_END(pix_norm1)

  647. 

  648. DEFUN(sse4,mL1,

  649.         (void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)):

  650.         link 0;

  651.         [--sp] = (r7:6);

  652.         p0=[fp+24];   // h

  653.         i0=r1;        // pix1

  654.         i1=r2;        // pix2

  655.         r2=[fp+20];   // line_size

  656.         r2+=-4;

  657.         m0=r2;

  658. 

  659.         a0=a1=0;

  660.         LSETUP(.S40,.E40) LC0=P0;

  661.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  662. 

  663. .S40:   DISALGNEXCPT                       || R1 = [I0++M0] || R3 = [I1++M0];

  664.         (R7,R6) = BYTEOP16M (R1:0,R3:2);

  665.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  666. .E40:   a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  667.         a0 += a1;

  668.         r0 = a0;

  669. 

  670.         (r7:6) = [sp++];

  671.         unlink;

  672.         rts;

  673. DEFUN_END(sse4)

  674. 

  675. DEFUN(sse8,mL1,

  676.         (void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)):

  677.         link 0;

  678.         [--sp] = (r7:6);

  679.         p0=[fp+24];   // h

  680.         i0=r1;        // pix1

  681.         i1=r2;        // pix2

  682.         r2=[fp+20];   // line_size

  683.         r2+=-8;

  684.         m0=r2;

  685. 

  686.         a0=a1=0;

  687.         LSETUP(.S80,.E80) LC0=P0;

  688.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  689. 

  690. .S80:   DISALGNEXCPT                       || R1 = [I0++]   || R3 = [I1++];

  691.         (R7,R6) = BYTEOP16M (R1:0,R3:2)    || R0 = [I0++M0] || R2 = [I1++M0];

  692.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  693.         a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  694.         (R7,R6) = BYTEOP16M (R1:0,R3:2) (R)|| R0 = [I0++]   || R2 = [I1++];

  695.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  696. .E80:   a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  697.         a0 += a1;

  698.         r0 = a0;

  699. 

  700.         (r7:6) = [sp++];

  701.         unlink;

  702.         rts;

  703. DEFUN_END(sse8)

  704. 

  705. DEFUN(sse16,mL1,

  706.         (void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)):

  707.         link 0;

  708.         [--sp] = (r7:6);

  709.         p0=[fp+24];   // h

  710.         i0=r1;        // pix1

  711.         i1=r2;        // pix2

  712.         r2=[fp+20];   // line_size

  713.         r2+=-16;

  714.         m0=r2;

  715. 

  716.         a0=a1=0;

  717.         DISALGNEXCPT                       || R0 = [I0++]   || R2  =[I1++];

  718.         LSETUP(.S160,.E160) LC0=P0;

  719. 

  720. .S160:  DISALGNEXCPT                       || R1 = [I0++]   || R3 = [I1++];

  721.         (R7,R6) = BYTEOP16M (R1:0,R3:2)    || R0 = [I0++]   || R2 = [I1++];

  722.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  723.         a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  724.         (R7,R6) = BYTEOP16M (R1:0,R3:2) (R)|| R1 = [I0++]   || R3 = [I1++];

  725.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  726.         a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  727.         (R7,R6) = BYTEOP16M (R1:0,R3:2)    || R0 = [I0++M0] || R2 = [I1++M0];

  728.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  729.         a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  730.         (R7,R6) = BYTEOP16M (R1:0,R3:2) (R)|| R0 = [I0++]   || R2 = [I1++];

  731.         a0 += r7.l * r7.l, a1 += r7.h * r7.h (is);

  732. .E160:  a0 += r6.l * r6.l, a1 += r6.h * r6.h (is);

  733.         a0 += a1;

  734.         r0 = a0;

  735. 

  736.         (r7:6) = [sp++];

  737.         unlink;

  738.         rts;

  739. DEFUN_END(sse16)