{-# LANGUAGE CPP #-}
{-# LANGUAGE TypeFamilies #-}
module Codec.Picture.Jpg.Internal.FastDct( referenceDct, fastDctLibJpeg ) where

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative( (<$>) )
#endif

import Data.Int( Int16, Int32 )
import Data.Bits( unsafeShiftR, unsafeShiftL )
import Control.Monad.ST( ST )

import qualified Data.Vector.Storable.Mutable as M

import Codec.Picture.Jpg.Internal.Types
import Control.Monad( forM, forM_ )

-- | Reference implementation of the DCT, directly implementing the formula

-- of ITU-81. It's slow as hell, perform to many operations, but is accurate

-- and a good reference point.

referenceDct :: MutableMacroBlock s Int32
             -> MutableMacroBlock s Int16
             -> ST s (MutableMacroBlock s Int32)
referenceDct :: forall s.
MutableMacroBlock s Int32
-> MutableMacroBlock s Int16 -> ST s (MutableMacroBlock s Int32)
referenceDct MutableMacroBlock s Int32
workData MutableMacroBlock s Int16
block = do
  forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [(Int
u, Int
v) | Int
u <- [Int
0 :: Int .. forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
- Int
1], Int
v <- [Int
0..forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
- Int
1]] forall a b. (a -> b) -> a -> b
$ \(Int
u,Int
v) -> do
    Float
val <- (Int, Int) -> ST s Float
at (Int
u,Int
v)
    (MutableMacroBlock s Int32
workData forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
`M.unsafeWrite` (Int
v forall a. Num a => a -> a -> a
* forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
+ Int
u)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (RealFrac a, Integral b) => a -> b
truncate forall a b. (a -> b) -> a -> b
$ (Float
1 forall a. Fractional a => a -> a -> a
/ Float
4) forall a. Num a => a -> a -> a
* forall {a} {a}. (Eq a, Num a, Floating a) => a -> a
c Int
u forall a. Num a => a -> a -> a
* forall {a} {a}. (Eq a, Num a, Floating a) => a -> a
c Int
v forall a. Num a => a -> a -> a
* Float
val

  forall (m :: * -> *) a. Monad m => a -> m a
return MutableMacroBlock s Int32
workData
 where -- at :: (Int, Int) -> ST s Float

   at :: (Int, Int) -> ST s Float
at (Int
u,Int
v) = do
     [Float]
toSum <-
        forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(Int
x,Int
y) | Int
x <- [Int
0..forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
- Int
1], Int
y <- [Int
0..forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
- Int
1 :: Int]] forall a b. (a -> b) -> a -> b
$ \(Int
x,Int
y) -> do
            Float
sample <- forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (MutableMacroBlock s Int16
block forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> m a
`M.unsafeRead` (Int
y forall a. Num a => a -> a -> a
* forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
+ Int
x))
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Float
sample forall a. Num a => a -> a -> a
* forall a. Floating a => a -> a
cos ((Float
2 forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x forall a. Num a => a -> a -> a
+ Float
1) forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
u forall a. Num a => a -> a -> a
* (forall a. Floating a => a
pi :: Float)forall a. Fractional a => a -> a -> a
/ Float
16) 
                            forall a. Num a => a -> a -> a
* forall a. Floating a => a -> a
cos ((Float
2 forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y forall a. Num a => a -> a -> a
+ Float
1) forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
v forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ Float
16)
     forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Float]
toSum

   c :: a -> a
c a
0 = a
1 forall a. Fractional a => a -> a -> a
/ forall a. Floating a => a -> a
sqrt a
2
   c a
_ = a
1

pASS1_BITS, cONST_BITS :: Int
cONST_BITS :: Int
cONST_BITS = Int
13
pASS1_BITS :: Int
pASS1_BITS =  Int
2


fIX_0_298631336, fIX_0_390180644, fIX_0_541196100,
    fIX_0_765366865, fIX_0_899976223, fIX_1_175875602,
    fIX_1_501321110, fIX_1_847759065, fIX_1_961570560,
    fIX_2_053119869, fIX_2_562915447, fIX_3_072711026 :: Int32
fIX_0_298631336 :: Int32
fIX_0_298631336 = Int32
2446    -- FIX(0.298631336) */

fIX_0_390180644 :: Int32
fIX_0_390180644 = Int32
3196    -- FIX(0.390180644) */

fIX_0_541196100 :: Int32
fIX_0_541196100 = Int32
4433    -- FIX(0.541196100) */

fIX_0_765366865 :: Int32
fIX_0_765366865 = Int32
6270    -- FIX(0.765366865) */

fIX_0_899976223 :: Int32
fIX_0_899976223 = Int32
7373    -- FIX(0.899976223) */

fIX_1_175875602 :: Int32
fIX_1_175875602 = Int32
9633    -- FIX(1.175875602) */

fIX_1_501321110 :: Int32
fIX_1_501321110 = Int32
12299    -- FIX(1.501321110) */

fIX_1_847759065 :: Int32
fIX_1_847759065 = Int32
15137    -- FIX(1.847759065) */

fIX_1_961570560 :: Int32
fIX_1_961570560 = Int32
16069    -- FIX(1.961570560) */

fIX_2_053119869 :: Int32
fIX_2_053119869 = Int32
16819    -- FIX(2.053119869) */

fIX_2_562915447 :: Int32
fIX_2_562915447 = Int32
20995    -- FIX(2.562915447) */

fIX_3_072711026 :: Int32
fIX_3_072711026 = Int32
25172    -- FIX(3.072711026) */


cENTERJSAMPLE :: Int32
cENTERJSAMPLE :: Int32
cENTERJSAMPLE = Int32
128

-- | Fast DCT extracted from libjpeg

fastDctLibJpeg :: MutableMacroBlock s Int32
        -> MutableMacroBlock s Int16
        -> ST s (MutableMacroBlock s Int32)
fastDctLibJpeg :: forall s.
MutableMacroBlock s Int32
-> MutableMacroBlock s Int16 -> ST s (MutableMacroBlock s Int32)
fastDctLibJpeg MutableMacroBlock s Int32
workData MutableMacroBlock s Int16
sample_block = do
 MutableMacroBlock s Int32 -> Int -> ST s ()
firstPass MutableMacroBlock s Int32
workData  Int
0
 forall s. STVector s Int32 -> Int -> ST s ()
secondPass MutableMacroBlock s Int32
workData Int
7
 {-_ <- mutate (\_ a -> a `quot` 8) workData-}
 forall (m :: * -> *) a. Monad m => a -> m a
return MutableMacroBlock s Int32
workData
  where -- Pass 1: process rows.

        -- Note results are scaled up by sqrt(8) compared to a true DCT;

        -- furthermore, we scale the results by 2**PASS1_BITS.

        firstPass :: MutableMacroBlock s Int32 -> Int -> ST s ()
firstPass         MutableMacroBlock s Int32
_ Int
i | Int
i forall a. Eq a => a -> a -> Bool
== forall a. Num a => a
dctBlockSize = forall (m :: * -> *) a. Monad m => a -> m a
return ()
        firstPass MutableMacroBlock s Int32
dataBlock Int
i = do
            let baseIdx :: Int
baseIdx = Int
i forall a. Num a => a -> a -> a
* forall a. Num a => a
dctBlockSize
                readAt :: Int -> ST s Int32
readAt Int
idx = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MutableMacroBlock s Int16
sample_block forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> m a
`M.unsafeRead` (Int
baseIdx forall a. Num a => a -> a -> a
+ Int
idx)
                mult :: Int32 -> Int32 -> Int32
mult = forall a. Num a => a -> a -> a
(*)
                writeAt :: Int -> Int32 -> ST s ()
writeAt Int
idx = MutableMacroBlock s Int32
dataBlock forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
`M.unsafeWrite` (Int
baseIdx forall a. Num a => a -> a -> a
+ Int
idx)
                writeAtPos :: Int -> Int32 -> ST s ()
writeAtPos Int
idx Int32
n = (MutableMacroBlock s Int32
dataBlock forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
`M.unsafeWrite` (Int
baseIdx forall a. Num a => a -> a -> a
+ Int
idx))
                                    (Int32
n forall a. Bits a => a -> Int -> a
`unsafeShiftR` (Int
cONST_BITS forall a. Num a => a -> a -> a
- Int
pASS1_BITS))

            Int32
blk0 <- Int -> ST s Int32
readAt Int
0
            Int32
blk1 <- Int -> ST s Int32
readAt Int
1
            Int32
blk2 <- Int -> ST s Int32
readAt Int
2
            Int32
blk3 <- Int -> ST s Int32
readAt Int
3
            Int32
blk4 <- Int -> ST s Int32
readAt Int
4
            Int32
blk5 <- Int -> ST s Int32
readAt Int
5
            Int32
blk6 <- Int -> ST s Int32
readAt Int
6
            Int32
blk7 <- Int -> ST s Int32
readAt Int
7

            let tmp0 :: Int32
tmp0 = Int32
blk0 forall a. Num a => a -> a -> a
+ Int32
blk7
                tmp1 :: Int32
tmp1 = Int32
blk1 forall a. Num a => a -> a -> a
+ Int32
blk6
                tmp2 :: Int32
tmp2 = Int32
blk2 forall a. Num a => a -> a -> a
+ Int32
blk5
                tmp3 :: Int32
tmp3 = Int32
blk3 forall a. Num a => a -> a -> a
+ Int32
blk4

                tmp10 :: Int32
tmp10 = Int32
tmp0 forall a. Num a => a -> a -> a
+ Int32
tmp3
                tmp12 :: Int32
tmp12 = Int32
tmp0 forall a. Num a => a -> a -> a
- Int32
tmp3
                tmp11 :: Int32
tmp11 = Int32
tmp1 forall a. Num a => a -> a -> a
+ Int32
tmp2
                tmp13 :: Int32
tmp13 = Int32
tmp1 forall a. Num a => a -> a -> a
- Int32
tmp2

                tmp0' :: Int32
tmp0' = Int32
blk0 forall a. Num a => a -> a -> a
- Int32
blk7
                tmp1' :: Int32
tmp1' = Int32
blk1 forall a. Num a => a -> a -> a
- Int32
blk6
                tmp2' :: Int32
tmp2' = Int32
blk2 forall a. Num a => a -> a -> a
- Int32
blk5
                tmp3' :: Int32
tmp3' = Int32
blk3 forall a. Num a => a -> a -> a
- Int32
blk4

            -- Stage 4 and output

            Int -> Int32 -> ST s ()
writeAt Int
0 forall a b. (a -> b) -> a -> b
$ (Int32
tmp10 forall a. Num a => a -> a -> a
+ Int32
tmp11 forall a. Num a => a -> a -> a
- forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
* Int32
cENTERJSAMPLE) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
pASS1_BITS
            Int -> Int32 -> ST s ()
writeAt Int
4 forall a b. (a -> b) -> a -> b
$ (Int32
tmp10 forall a. Num a => a -> a -> a
- Int32
tmp11) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
pASS1_BITS

            let z1 :: Int32
z1 = Int32 -> Int32 -> Int32
mult (Int32
tmp12 forall a. Num a => a -> a -> a
+ Int32
tmp13) Int32
fIX_0_541196100
                     forall a. Num a => a -> a -> a
+ (Int32
1 forall a. Bits a => a -> Int -> a
`unsafeShiftL` (Int
cONST_BITS forall a. Num a => a -> a -> a
- Int
pASS1_BITS forall a. Num a => a -> a -> a
- Int
1))

            Int -> Int32 -> ST s ()
writeAtPos Int
2 forall a b. (a -> b) -> a -> b
$ Int32
z1 forall a. Num a => a -> a -> a
+ Int32 -> Int32 -> Int32
mult Int32
tmp12 Int32
fIX_0_765366865
            Int -> Int32 -> ST s ()
writeAtPos Int
6 forall a b. (a -> b) -> a -> b
$ Int32
z1 forall a. Num a => a -> a -> a
- Int32 -> Int32 -> Int32
mult Int32
tmp13 Int32
fIX_1_847759065

            let tmp10' :: Int32
tmp10' = Int32
tmp0' forall a. Num a => a -> a -> a
+ Int32
tmp3'
                tmp11' :: Int32
tmp11' = Int32
tmp1' forall a. Num a => a -> a -> a
+ Int32
tmp2'
                tmp12' :: Int32
tmp12' = Int32
tmp0' forall a. Num a => a -> a -> a
+ Int32
tmp2'
                tmp13' :: Int32
tmp13' = Int32
tmp1' forall a. Num a => a -> a -> a
+ Int32
tmp3'
                z1' :: Int32
z1' = Int32 -> Int32 -> Int32
mult (Int32
tmp12' forall a. Num a => a -> a -> a
+ Int32
tmp13') Int32
fIX_1_175875602 --  c3 */

                        -- Add fudge factor here for final descale. */

                        forall a. Num a => a -> a -> a
+ (Int32
1 forall a. Bits a => a -> Int -> a
`unsafeShiftL` (Int
cONST_BITS forall a. Num a => a -> a -> a
- Int
pASS1_BITSforall a. Num a => a -> a -> a
-Int
1))
                tmp0'' :: Int32
tmp0'' = Int32 -> Int32 -> Int32
mult Int32
tmp0' Int32
fIX_1_501321110
                tmp1'' :: Int32
tmp1'' = Int32 -> Int32 -> Int32
mult Int32
tmp1' Int32
fIX_3_072711026
                tmp2'' :: Int32
tmp2'' = Int32 -> Int32 -> Int32
mult Int32
tmp2' Int32
fIX_2_053119869
                tmp3'' :: Int32
tmp3'' = Int32 -> Int32 -> Int32
mult Int32
tmp3' Int32
fIX_0_298631336

                tmp10'' :: Int32
tmp10'' = Int32 -> Int32 -> Int32
mult Int32
tmp10' (- Int32
fIX_0_899976223)
                tmp11'' :: Int32
tmp11'' = Int32 -> Int32 -> Int32
mult Int32
tmp11' (- Int32
fIX_2_562915447)
                tmp12'' :: Int32
tmp12'' = Int32 -> Int32 -> Int32
mult Int32
tmp12' (- Int32
fIX_0_390180644) forall a. Num a => a -> a -> a
+ Int32
z1'
                tmp13'' :: Int32
tmp13'' = Int32 -> Int32 -> Int32
mult Int32
tmp13' (- Int32
fIX_1_961570560) forall a. Num a => a -> a -> a
+ Int32
z1'

            Int -> Int32 -> ST s ()
writeAtPos Int
1 forall a b. (a -> b) -> a -> b
$ Int32
tmp0'' forall a. Num a => a -> a -> a
+ Int32
tmp10'' forall a. Num a => a -> a -> a
+ Int32
tmp12''
            Int -> Int32 -> ST s ()
writeAtPos Int
3 forall a b. (a -> b) -> a -> b
$ Int32
tmp1'' forall a. Num a => a -> a -> a
+ Int32
tmp11'' forall a. Num a => a -> a -> a
+ Int32
tmp13''
            Int -> Int32 -> ST s ()
writeAtPos Int
5 forall a b. (a -> b) -> a -> b
$ Int32
tmp2'' forall a. Num a => a -> a -> a
+ Int32
tmp11'' forall a. Num a => a -> a -> a
+ Int32
tmp12''
            Int -> Int32 -> ST s ()
writeAtPos Int
7 forall a b. (a -> b) -> a -> b
$ Int32
tmp3'' forall a. Num a => a -> a -> a
+ Int32
tmp10'' forall a. Num a => a -> a -> a
+ Int32
tmp13''

            MutableMacroBlock s Int32 -> Int -> ST s ()
firstPass MutableMacroBlock s Int32
dataBlock forall a b. (a -> b) -> a -> b
$ Int
i forall a. Num a => a -> a -> a
+ Int
1

        -- Pass 2: process columns.

        -- We remove the PASS1_BITS scaling, but leave the results scaled up

        -- by an overall factor of 8.

        secondPass :: M.STVector s Int32 -> Int -> ST s ()
        secondPass :: forall s. STVector s Int32 -> Int -> ST s ()
secondPass STVector s Int32
_     (-1) = forall (m :: * -> *) a. Monad m => a -> m a
return ()
        secondPass STVector s Int32
block Int
i = do
            let readAt :: Int -> ST s Int32
readAt Int
idx = STVector s Int32
block forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> m a
`M.unsafeRead` ((Int
7 forall a. Num a => a -> a -> a
- Int
i) forall a. Num a => a -> a -> a
+ Int
idx forall a. Num a => a -> a -> a
* forall a. Num a => a
dctBlockSize)
                mult :: Int32 -> Int32 -> Int32
mult = forall a. Num a => a -> a -> a
(*)
                writeAt :: Int -> Int32 -> ST s ()
writeAt Int
idx = STVector s Int32
block forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
`M.unsafeWrite` (forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
* Int
idx forall a. Num a => a -> a -> a
+ (Int
7 forall a. Num a => a -> a -> a
- Int
i))
                writeAtPos :: Int -> Int32 -> ST s ()
writeAtPos Int
idx Int32
n = (STVector s Int32
block forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
`M.unsafeWrite` (forall a. Num a => a
dctBlockSize forall a. Num a => a -> a -> a
* Int
idx forall a. Num a => a -> a -> a
+ (Int
7 forall a. Num a => a -> a -> a
- Int
i))) forall a b. (a -> b) -> a -> b
$ Int32
n forall a. Bits a => a -> Int -> a
`unsafeShiftR` (Int
cONST_BITS forall a. Num a => a -> a -> a
+ Int
pASS1_BITS forall a. Num a => a -> a -> a
+ Int
3)
            Int32
blk0 <- Int -> ST s Int32
readAt Int
0
            Int32
blk1 <- Int -> ST s Int32
readAt Int
1
            Int32
blk2 <- Int -> ST s Int32
readAt Int
2
            Int32
blk3 <- Int -> ST s Int32
readAt Int
3
            Int32
blk4 <- Int -> ST s Int32
readAt Int
4
            Int32
blk5 <- Int -> ST s Int32
readAt Int
5
            Int32
blk6 <- Int -> ST s Int32
readAt Int
6
            Int32
blk7 <- Int -> ST s Int32
readAt Int
7

            let tmp0 :: Int32
tmp0 = Int32
blk0 forall a. Num a => a -> a -> a
+ Int32
blk7
                tmp1 :: Int32
tmp1 = Int32
blk1 forall a. Num a => a -> a -> a
+ Int32
blk6
                tmp2 :: Int32
tmp2 = Int32
blk2 forall a. Num a => a -> a -> a
+ Int32
blk5
                tmp3 :: Int32
tmp3 = Int32
blk3 forall a. Num a => a -> a -> a
+ Int32
blk4

                -- Add fudge factor here for final descale. */

                tmp10 :: Int32
tmp10 = Int32
tmp0 forall a. Num a => a -> a -> a
+ Int32
tmp3 forall a. Num a => a -> a -> a
+ (Int32
1 forall a. Bits a => a -> Int -> a
`unsafeShiftL` (Int
pASS1_BITSforall a. Num a => a -> a -> a
-Int
1))
                tmp12 :: Int32
tmp12 = Int32
tmp0 forall a. Num a => a -> a -> a
- Int32
tmp3
                tmp11 :: Int32
tmp11 = Int32
tmp1 forall a. Num a => a -> a -> a
+ Int32
tmp2
                tmp13 :: Int32
tmp13 = Int32
tmp1 forall a. Num a => a -> a -> a
- Int32
tmp2

                tmp0' :: Int32
tmp0' = Int32
blk0 forall a. Num a => a -> a -> a
- Int32
blk7
                tmp1' :: Int32
tmp1' = Int32
blk1 forall a. Num a => a -> a -> a
- Int32
blk6
                tmp2' :: Int32
tmp2' = Int32
blk2 forall a. Num a => a -> a -> a
- Int32
blk5
                tmp3' :: Int32
tmp3' = Int32
blk3 forall a. Num a => a -> a -> a
- Int32
blk4

            Int -> Int32 -> ST s ()
writeAt Int
0 forall a b. (a -> b) -> a -> b
$ (Int32
tmp10 forall a. Num a => a -> a -> a
+ Int32
tmp11) forall a. Bits a => a -> Int -> a
`unsafeShiftR` (Int
pASS1_BITS forall a. Num a => a -> a -> a
+ Int
3)
            Int -> Int32 -> ST s ()
writeAt Int
4 forall a b. (a -> b) -> a -> b
$ (Int32
tmp10 forall a. Num a => a -> a -> a
- Int32
tmp11) forall a. Bits a => a -> Int -> a
`unsafeShiftR` (Int
pASS1_BITS forall a. Num a => a -> a -> a
+ Int
3)

            let z1 :: Int32
z1 = Int32 -> Int32 -> Int32
mult (Int32
tmp12 forall a. Num a => a -> a -> a
+ Int32
tmp13) Int32
fIX_0_541196100
                    forall a. Num a => a -> a -> a
+ (Int32
1 forall a. Bits a => a -> Int -> a
`unsafeShiftL` (Int
cONST_BITS forall a. Num a => a -> a -> a
+ Int
pASS1_BITS forall a. Num a => a -> a -> a
- Int
1))

            Int -> Int32 -> ST s ()
writeAtPos Int
2 forall a b. (a -> b) -> a -> b
$ Int32
z1 forall a. Num a => a -> a -> a
+ Int32 -> Int32 -> Int32
mult Int32
tmp12 Int32
fIX_0_765366865
            Int -> Int32 -> ST s ()
writeAtPos Int
6 forall a b. (a -> b) -> a -> b
$ Int32
z1 forall a. Num a => a -> a -> a
- Int32 -> Int32 -> Int32
mult Int32
tmp13 Int32
fIX_1_847759065

            let tmp10' :: Int32
tmp10' = Int32
tmp0' forall a. Num a => a -> a -> a
+ Int32
tmp3'
                tmp11' :: Int32
tmp11' = Int32
tmp1' forall a. Num a => a -> a -> a
+ Int32
tmp2'
                tmp12' :: Int32
tmp12' = Int32
tmp0' forall a. Num a => a -> a -> a
+ Int32
tmp2'
                tmp13' :: Int32
tmp13' = Int32
tmp1' forall a. Num a => a -> a -> a
+ Int32
tmp3'

                z1' :: Int32
z1' = Int32 -> Int32 -> Int32
mult (Int32
tmp12' forall a. Num a => a -> a -> a
+ Int32
tmp13') Int32
fIX_1_175875602
                    -- Add fudge factor here for final descale. */

                   forall a. Num a => a -> a -> a
+ Int32
1 forall a. Bits a => a -> Int -> a
`unsafeShiftL` (Int
cONST_BITSforall a. Num a => a -> a -> a
+Int
pASS1_BITSforall a. Num a => a -> a -> a
-Int
1);

                tmp0'' :: Int32
tmp0''  = Int32 -> Int32 -> Int32
mult Int32
tmp0'    Int32
fIX_1_501321110
                tmp1'' :: Int32
tmp1''  = Int32 -> Int32 -> Int32
mult Int32
tmp1'    Int32
fIX_3_072711026
                tmp2'' :: Int32
tmp2''  = Int32 -> Int32 -> Int32
mult Int32
tmp2'    Int32
fIX_2_053119869
                tmp3'' :: Int32
tmp3''  = Int32 -> Int32 -> Int32
mult Int32
tmp3'    Int32
fIX_0_298631336
                tmp10'' :: Int32
tmp10'' = Int32 -> Int32 -> Int32
mult Int32
tmp10' (- Int32
fIX_0_899976223)
                tmp11'' :: Int32
tmp11'' = Int32 -> Int32 -> Int32
mult Int32
tmp11' (- Int32
fIX_2_562915447)
                tmp12'' :: Int32
tmp12'' = Int32 -> Int32 -> Int32
mult Int32
tmp12' (- Int32
fIX_0_390180644)
                            forall a. Num a => a -> a -> a
+ Int32
z1'
                tmp13'' :: Int32
tmp13'' = Int32 -> Int32 -> Int32
mult Int32
tmp13' (- Int32
fIX_1_961570560)
                            forall a. Num a => a -> a -> a
+ Int32
z1'
            Int -> Int32 -> ST s ()
writeAtPos Int
1 forall a b. (a -> b) -> a -> b
$ Int32
tmp0'' forall a. Num a => a -> a -> a
+ Int32
tmp10'' forall a. Num a => a -> a -> a
+ Int32
tmp12''
            Int -> Int32 -> ST s ()
writeAtPos Int
3 forall a b. (a -> b) -> a -> b
$ Int32
tmp1'' forall a. Num a => a -> a -> a
+ Int32
tmp11'' forall a. Num a => a -> a -> a
+ Int32
tmp13''
            Int -> Int32 -> ST s ()
writeAtPos Int
5 forall a b. (a -> b) -> a -> b
$ Int32
tmp2'' forall a. Num a => a -> a -> a
+ Int32
tmp11'' forall a. Num a => a -> a -> a
+ Int32
tmp12''
            Int -> Int32 -> ST s ()
writeAtPos Int
7 forall a b. (a -> b) -> a -> b
$ Int32
tmp3'' forall a. Num a => a -> a -> a
+ Int32
tmp10'' forall a. Num a => a -> a -> a
+ Int32
tmp13''

            forall s. STVector s Int32 -> Int -> ST s ()
secondPass STVector s Int32
block (Int
i forall a. Num a => a -> a -> a
- Int
1)

{-# ANN module "HLint: ignore Use camelCase" #-}
{-# ANN module "HLint: ignore Reduce duplication" #-}