DecorrSamples
authorPHO <pho@cielonegro.org>
Sun, 9 Jan 2011 03:09:19 +0000 (12:09 +0900)
committerPHO <pho@cielonegro.org>
Sun, 9 Jan 2011 03:09:19 +0000 (12:09 +0900)
Codec/Audio/WavPack/Internal.hs [new file with mode: 0644]
Codec/Audio/WavPack/Metadata.hs
wavpack.cabal

diff --git a/Codec/Audio/WavPack/Internal.hs b/Codec/Audio/WavPack/Internal.hs
new file mode 100644 (file)
index 0000000..b852a76
--- /dev/null
@@ -0,0 +1,196 @@
+{-# LANGUAGE
+    BangPatterns
+  , UnicodeSyntax
+  #-}
+-- | WavPack internal functions
+module Codec.Audio.WavPack.Internal
+    ( packWeight
+    , unpackWeight
+
+    , log2s
+    , log2
+
+    , exp2s
+    , exp2
+    )
+    where
+import Data.Int
+import Data.Word
+import Data.Bits
+import qualified Data.Vector.Unboxed as UV
+import Prelude.Unicode
+
+-- | Convert internal weights (which are normally +/-1024) to an 8-bit
+-- signed character version for storage in metadata. The weights are
+-- clipped here in the case they are outside that range.
+packWeight ∷ Int16 → Word8
+packWeight !w
+    = let !w'   | w  >  1024 =  1024
+                | w  < -1024 = -1024
+                | otherwise  =     w
+          !w''  | w' >     0 = w' - ((w' + 64) `shiftR` 7)
+                | otherwise  = w'
+          !w'''              = (w'' + 4) `shiftR` 3
+      in
+        fromIntegral w'''
+
+-- | Convert a packed weight to internal weight (+/-1024). Note that
+-- the following equation might not hold because 'packWeight' is
+-- lossy.
+--
+-- > unpackWeight . packWeight = id
+--
+unpackWeight ∷ Word8 → Int16
+unpackWeight !w
+    = let w'  ∷ Int8
+          w'  = fromIntegral w
+          w'' ∷ Int16
+          w'' = (fromIntegral w') `shiftL` 3
+          !w''' | w'' > 0   = w'' + ((w'' + 64) `shiftR` 7)
+                | otherwise = w''
+      in
+        w'''
+
+-- | Return the 'log2' for the specified 32-bit signed integer. All
+-- input values are valid and the return values are in the range of
+-- +/-8192.
+log2s ∷ Int32 → Int16
+log2s !n
+    | n < 0     = fromIntegral $ negate $ log2 $ fromIntegral $ negate n
+    | otherwise = fromIntegral $ log2 $ fromIntegral n
+
+-- | The concept of a base 2 logarithm is used in many parts of
+-- WavPack. It is a way of sufficiently accurately representing 32-bit
+-- signed and unsigned values storing only 16 bits (actually
+-- fewer). It is also used in the hybrid mode for quickly comparing
+-- the relative magnitude of large values (i.e.  division) and
+-- providing smooth exponentials using only addition.
+--
+-- These are not strict logarithms in that they become linear around
+-- zero and can therefore represent both zero and negative
+-- values. They have 8 bits of precision and in \"roundtrip\"
+-- conversions the total error never exceeds 1 part in 225 except for
+-- the cases of +/-115 and +/-195 (which error by 1).
+--
+-- This function returns the log2 for the specified 32-bit unsigned
+-- value. The maximum value allowed is about 0xff800000 and returns
+-- 8447.
+log2 ∷ Word32 → Word16
+log2 !n
+    | n' < (1 `shiftL` 8)
+        = let dbits  ∷ Word16
+              dbits  = fromIntegral $ getNBits $ fromIntegral n'
+              !index = (n' `shiftL` fromIntegral (9 - dbits)) .&. 0xFF
+              !log2n = fromIntegral $ getLog2 $ fromIntegral index
+          in
+            (dbits `shiftL` 8) + log2n
+    | otherwise
+        = let dbits ∷ Word16
+              dbits | n' < (1 `shiftL` 16)
+                        = fromIntegral (getNBits $ fromIntegral $ n' `shiftR`  8) +  8
+                    | n' < (1 `shiftL` 24)
+                        = fromIntegral (getNBits $ fromIntegral $ n' `shiftR` 16) + 16
+                    | otherwise
+                        = fromIntegral (getNBits $ fromIntegral $ n' `shiftR` 24) + 24
+              !index = (n' `shiftR` fromIntegral (dbits - 9)) .&. 0xFF
+              !log2n = fromIntegral $ getLog2 $ fromIntegral index
+          in
+            (dbits `shiftL` 8) + log2n
+    where
+      n' ∷ Word32
+      n' = n + (n `shiftR` 9)
+
+-- | Return the original integer represented by the supplied logarithm
+-- (at least within the provided accuracy). The log is signed, but
+-- since a full 32-bit value is returned this can be used for unsigned
+-- conversions as well (i.e. the input range is -8192 to +8447).
+exp2s ∷ Int16 → Int32
+exp2s !l
+    | l < 0     = fromIntegral $ negate $ exp2 $ fromIntegral $ negate l
+    | otherwise = fromIntegral $ exp2 $ fromIntegral l
+
+-- | Return the original integer represented by the supplied logarithm
+-- (at least within the provided accuracy).
+exp2 ∷ Word16 → Word32
+exp2 !l
+    = let exp2l ∷ Word32
+          exp2l = fromIntegral (getExp2 $ fromIntegral $ l .&. 0xFF) .|. 0x100
+          l'    ∷ Word32
+          l'    = fromIntegral $ l `shiftR` 8
+      in
+        if l' ≤ 9 then
+            exp2l `shiftR` fromIntegral (9 - l')
+        else
+            exp2l `shiftL` fromIntegral (l' - 9)
+
+getNBits ∷ Word8 → Word8
+getNBits = UV.unsafeIndex nbitsTable ∘ fromIntegral
+    where
+      nbitsTable ∷ UV.Vector Word8
+      nbitsTable
+          = UV.fromList
+            [ 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 --   0 -  15
+            , 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 --  16 -  31
+            , 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 --  32 -  47
+            , 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 --  48 -  63
+            , 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 --  64 -  79
+            , 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 --  80 -  95
+            , 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 --  96 - 111
+            , 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 -- 112 - 127
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 128 - 143
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 144 - 159
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 160 - 175
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 176 - 191
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 192 - 207
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 208 - 223
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 224 - 239
+            , 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 -- 240 - 255
+            ]
+
+getLog2 ∷ Word8 → Word8
+getLog2 = UV.unsafeIndex log2Table ∘ fromIntegral
+    where
+      log2Table ∷ UV.Vector Word8
+      log2Table
+          = UV.fromList
+            [ 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0B, 0x0D, 0x0E, 0x10, 0x11, 0x12, 0x14, 0x15
+            , 0x16, 0x18, 0x19, 0x1a, 0x1C, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a
+            , 0x2C, 0x2D, 0x2E, 0x2F, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3B, 0x3C, 0x3D, 0x3E
+            , 0x3F, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4B, 0x4D, 0x4E, 0x4F, 0x50, 0x51
+            , 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63
+            , 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x74, 0x75
+            , 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85
+            , 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95
+            , 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9B, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4
+            , 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xaB, 0xaC, 0xaD, 0xaE, 0xaF, 0xB0, 0xB1, 0xB2, 0xB2
+            , 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xB9, 0xBa, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC0
+            , 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC6, 0xC7, 0xC8, 0xC9, 0xCa, 0xCB, 0xCB, 0xCC, 0xCD, 0xCE
+            , 0xCF, 0xD0, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD8, 0xD9, 0xDa, 0xDB
+            , 0xDC, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE4, 0xE5, 0xE6, 0xE7, 0xE7
+            , 0xE8, 0xE9, 0xEa, 0xEa, 0xEB, 0xEC, 0xED, 0xEE, 0xEE, 0xEF, 0xF0, 0xF1, 0xF1, 0xF2, 0xF3, 0xF4
+            , 0xF4, 0xF5, 0xF6, 0xF7, 0xF7, 0xF8, 0xF9, 0xF9, 0xFa, 0xFB, 0xFC, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF
+            ]
+
+getExp2 ∷ Word8 → Word8
+getExp2 = UV.unsafeIndex exp2Table ∘ fromIntegral
+    where
+      exp2Table ∷ UV.Vector Word8
+      exp2Table
+          = UV.fromList
+            [ 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0B
+            , 0x0B, 0x0C, 0x0D, 0x0E, 0x0E, 0x0F, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16
+            , 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1F, 0x20, 0x20, 0x21, 0x22, 0x23
+            , 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2B, 0x2C, 0x2C, 0x2D, 0x2E, 0x2F, 0x30
+            , 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3B, 0x3C, 0x3D
+            , 0x3E, 0x3F, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4B
+            , 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a
+            , 0x5B, 0x5C, 0x5D, 0x5E, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69
+            , 0x6a, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79
+            , 0x7a, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a
+            , 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9B
+            , 0x9C, 0x9D, 0x9F, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xaB, 0xaC, 0xaD
+            , 0xaF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB6, 0xB7, 0xB8, 0xB9, 0xBa, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0
+            , 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC8, 0xC9, 0xCa, 0xCB, 0xCD, 0xCE, 0xCF, 0xD0, 0xD2, 0xD3, 0xD4
+            , 0xD6, 0xD7, 0xD8, 0xD9, 0xDB, 0xDC, 0xDD, 0xDE, 0xE0, 0xE1, 0xE2, 0xE4, 0xE5, 0xE6, 0xE8, 0xE9
+            , 0xEa, 0xEC, 0xED, 0xEE, 0xF0, 0xF1, 0xF2, 0xF4, 0xF5, 0xF6, 0xF8, 0xF9, 0xFa, 0xFC, 0xFD, 0xFF
+            ]
index d8c0df1e592d889c1b203acb5a2ef3dd99d790f5..00e1d02e2631340d426f66a04d9909bc26364d8f 100644 (file)
@@ -11,11 +11,13 @@ module Codec.Audio.WavPack.Metadata
     , Dummy(..)
     , DecorrTerms(..)
     , DecorrWeights(..)
+    , DecorrSamples(..)
     , RIFFHeader(..)
     , RIFFTrailer(..)
     , Unknown(..)
     )
     where
+import Codec.Audio.WavPack.Internal
 import Control.Monad
 import Data.Binary
 import Data.Binary.Get
@@ -94,6 +96,7 @@ instance Binary SubBlock where
           getSubBlock 0x00 = fmap SubBlock (get ∷ Get Dummy        )
           getSubBlock 0x02 = fmap SubBlock (get ∷ Get DecorrTerms  )
           getSubBlock 0x03 = fmap SubBlock (get ∷ Get DecorrWeights)
+          getSubBlock 0x04 = fmap SubBlock (get ∷ Get DecorrSamples)
           getSubBlock 0x21 = fmap SubBlock (get ∷ Get RIFFHeader   )
           getSubBlock 0x22 = fmap SubBlock (get ∷ Get RIFFTrailer  )
           getSubBlock unknownID
@@ -177,35 +180,36 @@ instance Metadata DecorrWeights where
     metaSize = fromIntegral ∘ UV.length ∘ decwVec
 
 instance Binary DecorrWeights where
-    put = UV.mapM_ (putWord8 ∘ packW) ∘ decwVec
-        where
-          packW ∷ Int16 → Word8
-          packW w
-              = let w'   | w  >  1024 =  1024
-                         | w  < -1024 = -1024
-                         | otherwise  =     w
-                    w''  | w' >     0 = w' - ((w' + 64) `shiftR` 7)
-                         | otherwise  = w'
-                    w'''              = (w'' + 4) `shiftR` 3
-                in
-                  fromIntegral w'''
+    put = UV.mapM_ (putWord8 ∘ packWeight) ∘ decwVec
     get = do n   ← remaining
-             vec ← UV.replicateM (fromIntegral n) $ fmap unpackW getWord8
+             vec ← UV.replicateM (fromIntegral n)
+                    $ fmap unpackWeight getWord8
              -- THINKME: the same caution as DecorrTerms, but never
-             -- try to reverse the vector simply. Think about the
+             -- try to simply reverse the vector. Think about the
              -- interleaving.
              return $ DecorrWeights vec
-        where
-          unpackW ∷ Word8 → Int16
-          unpackW w
-              = let w'  ∷ Int8
-                    w'  = fromIntegral w
-                    w'' ∷ Int16
-                    w'' = (fromIntegral w') `shiftL` 3
-                    w''' | w'' > 0   = w'' + ((w'' + 64) `shiftR` 7)
-                         | otherwise = w''
-                in
-                  w'''
+
+-- | Decorrelation samples
+data DecorrSamples
+    = DecorrSamples {
+      -- | The decorrelation sample vector stored in the metadata
+      --   as-is. Actual interpretation of the vector depends on the
+      --   number of channels and each corresponding decorrelation
+      --   terms.
+        decsVec ∷ !(UV.Vector Int32)
+      }
+    deriving (Eq, Show, Typeable)
+
+instance Metadata DecorrSamples where
+    metaID _ = 0x04
+    metaSize = fromIntegral ∘ (⋅ 2) ∘ UV.length ∘ decsVec
+
+instance Binary DecorrSamples where
+    put = UV.mapM_ (putWord16le ∘ fromIntegral ∘ log2s) ∘ decsVec
+    get = do n   ← remaining
+             vec ← UV.replicateM (fromIntegral $ n `div` 2)
+                    $ fmap (exp2s ∘ fromIntegral) getWord16le
+             return $ DecorrSamples vec
 
 -- | RIFF header for .wav files (before audio)
 data RIFFHeader
index cead654fc62e49663a38ee9335d30c9a548b16ad..7001778ca3d6c9d590267d151eb44f658facb83a 100644 (file)
@@ -38,6 +38,7 @@ Library
         Codec.Audio.WavPack
         Codec.Audio.WavPack.Block
         Codec.Audio.WavPack.Decorrelation
+        Codec.Audio.WavPack.Internal
         Codec.Audio.WavPack.Metadata
 
     GHC-Options: