Steel Bank Common Lisp

On Tue, 17 Feb 2009, fred voisin <fred@...> writes:
> may be it's trivial, I'm quite surprised to not succeed in reading
> binary files, as for instance pbm file (but also some other formats for
> audio etc).
> Here is a code I took (after all) from Gimp tools for testing, very
> close to my own code :
>
> (defun read-without-comment (s)
>   "Reads the next data from stream S, skipping any comments."
>   (if (eq (peek-char nil s) #\#)
>       (progn
> 	(read-line s)
> 	(read-without-comment s))
>       (read s)))
>
> (defun read-pbm (filename)
>   "Read a binary PBM file and returns a BINARY-IMAGE."
>   (let (width height pos)
>     (with-open-file (s filename)
>       (when (not (equal (symbol-name (read s)) "P4"))
> 	(error "not a binary PBM file" ))
>       (setf width  (read-without-comment s)
> 	    height (read-without-comment s)
> 	    pos    (file-position s)))
>     (let ((data (make-array (* (ceiling width 8) height)
> 			    :element-type '(unsigned-byte 8))))
>       (with-open-file (s filename :element-type '(unsigned-byte 8))
> 	(file-position s pos)
> 	(read-sequence data s))
>       (print data))))

Excuse my ignorance, but aren't PBM files of binary format composed of
ASCII character 0/1 columns? If so, why do you use `(UNSIGNED-BYTE 8)'?
I used below lines to parse a sample PBM file.

  (defun read-line-ignoring-comments (stream)
    (let ((line (read-line stream nil nil)))
      (when line
        (if (eql (elt line 0) #\#)
            ;; Ignore current comment line and continue with the next.
            (read-line-ignoring-comments stream)
            line))))
  
  (defgeneric read-pbm (format filename))
  
  (defmethod read-pbm ((format (eql (or :p1 :p4))) filename)
    (with-open-file (stream filename)
      (let ((signature (read-line-ignoring-comments stream)))
        (unless (member signature '("P1" "P4") :test #'string-equal)
          (error "Unknown PBM file of format P1/P1."))
        (destructuring-bind (w h)
            ;; Read image dimensions.
            (with-input-from-string (stream (read-line-ignoring-comments stream))
              (list (read stream) (read stream)))
          ;; Read image data bit per bit using `READ'.
          (let ((data (make-array (* w h) :element-type 'bit :initial-element 0)))
            (dotimes (i h)
              (dotimes (j w)
                (setf (elt data (+ (* i h) j)) (read stream))))
            (list w h data))))))
  
  ; $ cat /tmp/foo.pbm
  ; P4
  ; # foo.pbm
  ; 10 10
  ; 0 1 0 0 0 1 0 1 0 1
  ; 1 1 0 0 1 1 0 1 0 0
  ; 0 1 0 0 0 1 0 1 0 1
  ; 1 1 0 0 1 1 0 1 0 0
  ; 0 1 0 0 0 1 0 1 0 1
  ; 1 1 0 0 1 1 0 1 0 0
  ; 0 1 0 0 0 1 0 1 0 1
  ; 1 1 0 0 1 1 0 1 0 0
  ; 0 1 0 0 0 1 0 1 0 1
  ; 1 1 0 0 1 1 0 1 0 0
            
  TEST> (read-pbm :p1 "/tmp/foo.ppm")
  (10 10 #*0100010101110011010001000101011100110100010001010111001101000100010101110011010001000101011100110100)

BTW, there are probably more efficient ways of reading such a file,
instead of calling `READ' function WxH times. Exploring zpng/skippy
sources can be helpful.


Regards.

2009/2/17 fred voisin <fred@...>:

> may be it's trivial, I'm quite surprised to not succeed in reading
> binary files, as for instance pbm file (but also some other formats for
> audio etc).
> Here is a code I took (after all) from Gimp tools for testing, very
> close to my own code :

...snip...

> this output looks very strange, not as expected and '(unsigned-byte from
> 1 to 16 change nothing) - shouldn't be only zeros (0) and ones (1), I
> remember having that times ago (some cool old code I did doesn't work now) ?

Please provide a sample file, along with expected results from using
your code on it.

Cheers,

 -- Nikodemus

On Tue, Feb 17, 2009 at 10:52 AM, fred voisin <fred@...> wrote:
> may be it's trivial, I'm quite surprised to not succeed in reading
> binary files, as for instance pbm file (but also some other formats for
> audio etc).

  This code works perfectly fine for me with Darwin PPC and Linux x86.
  Looking at your output, I think the problem is in your memory of PBM
  binary files.  With PBM ASCII files, there are only zeros and ones.
  With PBM binary files, the bits are packed eight to a byte.... hence
  the (CEILING WIDTH 8).

  Here is some C code that outputs a sample PBM file that's easy to
  verify is read correctly:

/*---------------------------------------------------------------*/
#include <stdio.h>

enum {  WIDTH = 122 };
enum { HEIGHT =  16 };

int
main( void )
{
 unsigned int ii;

 fprintf( stdout, "P4\n" );
 fprintf( stdout, "# test PBM file\n" );
 fprintf( stdout, "%d %d\n", WIDTH, HEIGHT );

 for ( ii=0; ii < ( ( WIDTH + 7 ) / 8 ) * HEIGHT; ++ii ) {
   fputc( (unsigned char)ii, stdout );
 }

 fflush( stdout );
 fclose( stdout );

 return 0;
}
/*---------------------------------------------------------------*/

  And, I changed your (print data) to (values data width height).
  Here are the results:

CL-USER(3): (read-pbm #P"test.pbm")

#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255)
122
16

ttyl,
Patrick

Patrick Stein a écrit :
> On Tue, Feb 17, 2009 at 10:52 AM, fred voisin <fred@...> wrote:
>> may be it's trivial, I'm quite surprised to not succeed in reading
>> binary files, as for instance pbm file (but also some other formats for
>> audio etc).
> 
>   This code works perfectly fine for me with Darwin PPC and Linux x86.
>   Looking at your output, I think the problem is in your memory of PBM
>   binary files.  With PBM ASCII files, there are only zeros and ones.
>   With PBM binary files, the bits are packed eight to a byte.... hence
>   the (CEILING WIDTH 8).
> 

Thank's for all your answers (Volkan, Nikodemus, Patrick),
finally I got it, the only point was just, as you said, that in P4
binary PBM files the bits are packed eight to a byte so I had success
(read generated from your c code) using the following (rough and very
basic) lisp function to convert bytes red with read-byte:

(defun int8bits (n r)
  (if (> n 1)
      (int8bits (floor (/ n 2)) (cons (mod n 2) r))
      (let ((r (cons n r)))
	(append (make-list (- 8 (length r)) :initial-element 0) r))))

(int8bits 128 nil)
> (1 0 0 0 0 0 0 0)

I suspect there is a faster and nicer lisp way to do it, please which
one do you suggest ?

Thank's in advance,
Regards,

Fred