[Haskell-beginners] FFI Problems

Thomas Jakway tjakway at nyu.edu
Tue Mar 3 19:27:08 UTC 2015


Thanks very much!  This helped a lot (and you were right on #2... I 
really should have caught that).

On 3/2/15 10:20 AM, Sylvain Henry wrote:
> Hi,
>
> 1) You have a copy-paste error on the following line (s/bitrate/track)
>  track <- ((#peek struct music_metadata, bitrate) a) :: IO Int
>
> 2) By looking at the values you get in hexadecimal, you are reading 
> 64bits values when your C struct contains 32 bits values. If you use: 
> peek ... :: IO Int32, it should be ok.
>
> 3) From a style point of view, you could use Applicative operators 
> (from Control.Applicative) to avoid temporary names:
> peek a = MusicMetaData
>         <$> liftM constantToCodec $ (((#peek struct music_metadata, 
> codec) a) :: IO Int32)
>         <*> fmap fromIntegral (((#peek struct music_metadata, length) 
> a) :: IO Int32)
>         <*> fmap fromIntegral (((#peek struct music_metadata, bitrate) 
> a) :: IO Int32)
>         <*> fmap fromIntegral (((#peek struct music_metadata, 
> channels) a) :: IO Int32)
>         <*> fmap fromIntegral (((#peek struct music_metadata, track) 
> a) :: IO Int32)
>         <*> (peekCString =<< (#peek struct music_metadata, title) a)
>         ...
>
> 4) In your constantToCodec function, you don't need the temporary 
> names for all the constants.
>
> Best regards,
> Sylvain
>
> PS : recently I have been working on rewriting the FFI page on the 
> wiki to make it more beginner-friendly ;-). It is not totally finished 
> but I'm open to any comment. 
> https://www.haskell.org/wiki/Foreign_Function_Interface
>
> 2015-02-28 14:20 GMT+01:00 Thomas Jakway <tjakway at nyu.edu 
> <mailto:tjakway at nyu.edu>>:
>
>     I'm very new to Haskell and am trying to write a "real" program to
>     motivate myself to learn it better (so far I've only gotten
>     through Project Euler problems after reading LYAH and most of
>     RWH).  I'm using Taglib (https://github.com/taglib/taglib) to read
>     the metadata from a music file and print it.  I have a struct
>     C-side (with C linkage) serving as the bridge between Taglib's C++
>     and Haskell's FFI.  A small demo program (compiled with gcc and
>     linked against the C++ object files) gives the correct results,
>     but Haskell is weirdly only getting /some /of it right.
>     Specifically, the C string fields are working but ints are not.
>
>     The output from the C demo (what Haskell should be printing):
>
>     music_metadata
>     title: It's My Life,    artist: Bon Jovi,    album: Bon Jovi
>     Greatest Hits - The Ultimate Collection
>     comment: ,    genre: Rock,    track: 3,
>     length: 224,    bitrate: 256,    channels: 2,
>     codec: 768
>
>     The output from Haskell:
>
>     MusicMetadata {codec = UNKNOWN, length = 1099511628000, bitrate =
>     8589934848 <tel:8589934848>, channels = 12884901890, track =
>     8589934848 <tel:8589934848>, title = "It's My Life", artist = "Bon
>     Jovi", album = "Bon Jovi Greatest Hits - The Ultimate Collection",
>     comment = "", genre = "Rock"}
>
>     I would have expected it to work or not work at all, but did not
>     anticipate getting only some of it right.
>
>     I was going to include snippets from my hsc file but given how new
>     I am to Haskell I don't trust myself to assume where the problem
>     is, so sorry if this is way too long:
>
>     {-# LANGUAGE CPP, ForeignFunctionInterface #-}
>
>     module MusicReader
>     ( Codec,
>       MusicMetadata,
>       readMusicMetadata
>     ) where
>
>     import Control.Monad
>     import Foreign
>     import Foreign.C.Types
>     import Foreign.C.String
>     import System.IO.Unsafe as Unsafe
>
>     #include "CodecDefines.h"
>     #include "MusicReader.h"
>
>     constantToCodec code
>                         | code == mp3 = MP3
>                         | code == flac = FLAC
>                         | code == ogg = OGG_VORBIS
>                         | code == mp4 = MP4
>                         | code == mpeg = MPEG
>                         | code == none = NONE
>                         | code == unknown = UNKNOWN
>                         | otherwise = UNKNOWN
>                            where mp3 = #const MP3_CODEC
>                                  flac = #const FLAC_CODEC
>                                  ogg = #const OGG_VORBIS_CODEC
>                                  mp4 = #const MP4_CODEC
>                                  mpeg = #const MPEG_CODEC
>                                  none = #const NO_EXTENSION
>                                  unknown = #const UNKNOWN_EXTENSION
>
>     data Codec = MP3 | FLAC | OGG_VORBIS | MP4 | MPEG | NONE | UNKNOWN
>     deriving (Show)
>
>     data MusicMetadata = MusicMetadata { codec :: Codec,
>                           length :: Int,
>                           bitrate :: Int,
>                           channels :: Int,
>                           track :: Int,
>                           title :: String,
>                           artist :: String,
>                           album :: String,
>                           comment :: String,
>                           genre :: String } deriving (Show)
>
>     instance Storable MusicMetadata where
>         sizeOf _ = (#size struct music_metadata)
>         alignment _ = alignment (undefined::CDouble)
>         peek a = do
>             codec <- liftM constantToCodec $ (((#peek struct
>     music_metadata, codec) a) :: IO Int)
>             length <- ((#peek struct music_metadata, length) a) :: IO Int
>             bitrate <- ((#peek struct music_metadata, bitrate) a) ::
>     IO Int
>             channels <- ((#peek struct music_metadata, channels) a) ::
>     IO Int
>             track <- ((#peek struct music_metadata, bitrate) a) :: IO Int
>             title <-  ((#peek struct music_metadata, title) a) :: IO
>     CString
>             artist <- ((#peek struct music_metadata, artist) a) :: IO
>     CString
>             album <- ((#peek struct music_metadata, album) a) :: IO
>     CString
>             comment <- ((#peek struct music_metadata, comment) a) ::
>     IO CString
>             genre <- ((#peek struct music_metadata, genre) a) :: IO
>     CString
>             --FIXME: find replacement for temporary names
>             marshalledTitle <- peekCString title
>             marshalledArtist <- peekCString artist
>             marshalledAlbum <- peekCString album
>             marshalledComment <- peekCString comment
>             marshalledGenre <- peekCString genre
>             return (MusicMetadata codec length bitrate channels track
>     marshalledTitle marshalledArtist marshalledAlbum marshalledComment
>     marshalledGenre)
>         poke a = undefined
>
>     --This is the "primitive" FFI call--calls the C function and gets
>     a pointer
>     --in return
>     --TODO: write a higher level function this module should export
>     that calls
>     --primReadMusicMetadata and converts the C Pointer into the
>     Haskell data
>     --MusicMetadata
>     foreign import ccall unsafe "read_metadata" primReadMusicMetadata
>     :: CString -> IO (Ptr MusicMetadata)
>
>     --convert the Haskell string to a CString, call into the FFI then
>     --dereference the resulting pointer
>     readMusicMetadata a = join $ withCString a $ \cs -> ((liftM peek)
>     $ primReadMusicMetadata cs)
>
>
>
>     Here's the struct in MusicReader.h (in an extern C block):
>         struct music_metadata
>         {
>             int codec;
>             int length,
>                     bitrate,
>                     channels;
>             int track;
>             char *title,
>                  *artist,
>                  *album,
>                  *comment,
>                  *genre;
>         };
>
>
>     with the corresponding call:
>         struct music_metadata* read_metadata(char*);
>
>
>     I've tried playing around with the alignment but it didn't do
>     anything.  I also tried declaring the struct's fields as int32_t
>     which also did nothing.
>
>     The C demo in question is a very simple:
>
>     #include <stdio.h>
>     #include "MusicReader.h"
>
>     #define FILENAME "Its_My_Life.m4a"
>
>     int main()
>     {
>         struct music_metadata* metadata = read_metadata(FILENAME);
>         printf("music_metadata\ntitle: %s,\tartist: %s,\talbum: %s\n",
>                 metadata->title, metadata->artist, metadata->album);
>         printf("comment: %s,\tgenre: %s,\ttrack: %d,\n",
>                 metadata->comment, metadata->genre, metadata->track);
>         printf("length: %d,\tbitrate: %d,\tchannels: %d,\n",
>                 metadata->length, metadata->bitrate, metadata->channels);
>         printf("codec: %d\n");
>
>     }
>
>     It just reads the metadata into the struct and prints the fields.
>
>     I've gotten the impression of the Haskell FFI being very
>     beginner-unfriendly, which isn't surprising but still
>     disappointing because it would be a great opportunity to replace
>     some projects with Haskell.
>
>     Any help is appreciated, including general feedback on my code!
>
>     _______________________________________________
>     Beginners mailing list
>     Beginners at haskell.org <mailto:Beginners at haskell.org>
>     http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20150303/5b0e0d62/attachment-0001.html>


More information about the Beginners mailing list