view release on metacpan or  search on metacpan

lib/Image/Leptonica/Func/jpegio.pm  view on Meta::CPAN

=head2 fgetJpegResolution

l_int32 fgetJpegResolution ( FILE *fp, l_int32 *pxres, l_int32 *pyres )

  fgetJpegResolution()

      Input:  stream (opened for read)
              &xres, &yres (<return> resolution in ppi)
      Return: 0 if OK; 1 on error

  Notes:
      (1) If neither resolution field is set, this is not an error;
          the returned resolution values are 0 (designating 'unknown').
      (2) Side-effect: this rewinds the stream.

=head2 freadHeaderJpeg

l_int32 freadHeaderJpeg ( FILE *fp, l_int32 *pw, l_int32 *ph, l_int32 *pspp, l_int32 *pycck, l_int32 *pcmyk )

  freadHeaderJpeg()

      Input:  stream
              &w (<optional return>)
              &h (<optional return>)
              &spp (<optional return>, samples/pixel)
              &ycck (<optional return>, 1 if ycck color space; 0 otherwise)
              &cmyk (<optional return>, 1 if cmyk color space; 0 otherwise)
      Return: 0 if OK, 1 on error

=head2 pixReadJpeg

PIX * pixReadJpeg ( const char *filename, l_int32 cmflag, l_int32 reduction, l_int32 *pnwarn )

  pixReadJpeg()

      Input:  filename
              colormap flag (0 means return RGB image if color;
                             1 means create colormap and return 8 bpp
                               palette image if color)
              reduction (scaling factor: 1, 2, 4 or 8)
              &nwarn (<optional return> number of warnings about
                       corrupted data)
      Return: pix, or null on error

  Images reduced by factors of 2, 4 or 8 can be returned
  significantly faster than full resolution images.

  The jpeg library will return warnings (or exit) if
  the jpeg data is bad.  Use this function if you want the
  jpeg library to create an 8 bpp palette image, or to
  tell if the jpeg data has been corrupted.  For corrupt jpeg
  data, there are two possible outcomes:
    (1) a damaged pix will be returned, along with a nonzero
        number of warnings, or
    (2) for sufficiently serious problems, the library will attempt
        to exit (caught by our error handler) and no pix will be returned.

=head2 pixReadMemJpeg

PIX * pixReadMemJpeg ( const l_uint8 *cdata, size_t size, l_int32 cmflag, l_int32 reduction, l_int32 *pnwarn, l_int32 hint )

  pixReadMemJpeg()

      Input:  cdata (const; jpeg-encoded)
              size (of data)
              colormap flag (0 means return RGB image if color;
                             1 means create colormap and return 8 bpp
                               palette image if color)
              reduction (scaling factor: 1, 2, 4 or 8)
              &nwarn (<optional return> number of warnings)
              hint (bitwise OR of L_HINT_* values; use 0 for no hint)
      Return: pix, or null on error

  Notes:
      (1) The @size byte of @data must be a null character.
      (2) See pixReadJpeg() for usage.

=head2 pixReadStreamJpeg

PIX * pixReadStreamJpeg ( FILE *fp, l_int32 cmflag, l_int32 reduction, l_int32 *pnwarn, l_int32 hint )

  pixReadStreamJpeg()

      Input:  stream
              colormap flag (0 means return RGB image if color;
                             1 means create colormap and return 8 bpp
                               palette image if color)
              reduction (scaling factor: 1, 2, 4 or 8)
              &nwarn (<optional return> number of warnings)
              hint: (a bitwise OR of L_HINT_* values); use 0 for no hints
      Return: pix, or null on error

  Usage: see pixReadJpeg()
  Notes:
      (1) This does not get the jpeg comment.

=head2 pixSetChromaSampling

l_int32 pixSetChromaSampling ( PIX *pix, l_int32 sampling )

  pixSetChromaSampling()

      Input:  pix
              sampling (1 for subsampling; 0 for no subsampling)
      Return: 0 if OK, 1 on error

  Notes:
      (1) The default is for 2x2 chroma subsampling because the files are
          considerably smaller and the appearance is typically satisfactory.
          Call this with @sampling == 0 for full resolution output in
          chroma channels for jpeg writing.

=head2 pixWriteJpeg

l_int32 pixWriteJpeg ( const char *filename, PIX *pix, l_int32 quality, l_int32 progressive )

  pixWriteJpeg()

      Input:  filename
              pix
              quality (1 - 100; 75 is default)
              progressive (0 for baseline sequential; 1 for progressive)
      Return: 0 if OK; 1 on error

lib/Image/Leptonica/Func/jpegio.pm  view on Meta::CPAN

      Return: 0 if OK, 1 on error

  Notes:
      (1) See pixWriteStreamJpeg() for usage.  This version writes to
          memory instead of to a file stream.

=head2 pixWriteStreamJpeg

l_int32 pixWriteStreamJpeg ( FILE *fp, PIX *pix, l_int32 quality, l_int32 progressive )

  pixWriteStreamJpeg()

      Input:  stream
              pix  (8 or 32 bpp)
              quality  (1 - 100; 75 is default value; 0 is also default)
              progressive (0 for baseline sequential; 1 for progressive)
      Return: 0 if OK, 1 on error

  Notes:
      (1) Under the covers, the library transforms rgb to a
          luminence-chromaticity triple, each component of which is
          also 8 bits, and compresses that.  It uses 2 Huffman tables,
          a higher resolution one (with more quantization levels)
          for luminosity and a lower resolution one for the chromas.
      (2) Progressive encoding gives better compression, at the
          expense of slower encoding and decoding.
      (3) Standard chroma subsampling is 2x2 on both the U and V
          channels.  For highest quality, use no subsampling; this
          option is set by pixSetChromaSampling(pix, 0).
      (4) There are three possibilities:
          * Grayscale image, no colormap: compress as 8 bpp image.
          * rgb full color image: copy each line into the color
            line buffer, and compress as three 8 bpp images.
          * 8 bpp colormapped image: convert each line to three
            8 bpp line images in the color line buffer, and
            compress as three 8 bpp images.
      (5) The only valid pixel depths in leptonica are 1, 2, 4, 8, 16
          and 32 bpp.  However, it is possible, and in some cases desirable,
          to write out a jpeg file using an rgb pix that has 24 bpp.
          This can be created by appending the raster data for a 24 bpp
          image (with proper scanline padding) directly to a 24 bpp
          pix that was created without a data array.  See note in
          pixWriteStreamPng() for an example.

=head2 readHeaderJpeg

l_int32 readHeaderJpeg ( const char *filename, l_int32 *pw, l_int32 *ph, l_int32 *pspp, l_int32 *pycck, l_int32 *pcmyk )

  readHeaderJpeg()

      Input:  filename
              &w (<optional return>)
              &h (<optional return>)
              &spp (<optional return>, samples/pixel)
              &ycck (<optional return>, 1 if ycck color space; 0 otherwise)
              &cmyk (<optional return>, 1 if cmyk color space; 0 otherwise)
      Return: 0 if OK, 1 on error

=head2 readHeaderMemJpeg

l_int32 readHeaderMemJpeg ( const l_uint8 *cdata, size_t size, l_int32 *pw, l_int32 *ph, l_int32 *pspp, l_int32 *pycck, l_int32 *pcmyk )

  readHeaderMemJpeg()

      Input:  cdata (const; jpeg-encoded)
              size (of data)
              &w (<optional return>)
              &h (<optional return>)
              &spp (<optional return>, samples/pixel)
              &ycck (<optional return>, 1 if ycck color space; 0 otherwise)
              &cmyk (<optional return>, 1 if cmyk color space; 0 otherwise)
      Return: 0 if OK, 1 on error

=head1 AUTHOR

Zakariyya Mughal <zmughal@cpan.org>

=head1 COPYRIGHT AND LICENSE

This software is copyright (c) 2014 by Zakariyya Mughal.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.

=cut