← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gimp/utopic

« back to all changes in this revision

Viewing changes to plug-ins/common/file-xwd.c

  • Committer: Package Import Robot
  • Author(s): Ari Pollak
  • Date: 2013-02-23 11:52:27 UTC
  • mto: (1.1.28) (0.6.1 sid)
  • mto: This revision was merged to the branch mainline in revision 77.
  • Revision ID: package-import@ubuntu.com-20130223115227-erjyrlri4ku3ysap
Import upstream version 2.8.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/common/file-xwd.c
186
186
static gint32 load_xwd_f2_d24_b32 (const gchar *,
187
187
                                   FILE *,
188
188
                                   L_XWDFILEHEADER *,
189
 
                                   L_XWDCOLOR *);
 
189
                                   L_XWDCOLOR *,
 
190
                                   GError **);
190
191
static gint32 load_xwd_f1_d24_b1  (const gchar *,
191
192
                                   FILE *,
192
193
                                   L_XWDFILEHEADER *,
193
 
                                   L_XWDCOLOR *);
 
194
                                   L_XWDCOLOR *,
 
195
                                   GError **);
194
196
 
195
197
static L_CARD32 read_card32  (FILE *,
196
198
                              gint *);
540
542
    case 1:    /* Single plane pixmap */
541
543
      if ((depth <= 24) && (bpp == 1))
542
544
        {
543
 
          image_ID = load_xwd_f1_d24_b1 (filename, ifp, &xwdhdr, xwdcolmap);
 
545
          image_ID = load_xwd_f1_d24_b1 (filename, ifp, &xwdhdr, xwdcolmap,
 
546
                                         error);
544
547
        }
545
548
      break;
546
549
 
559
562
        }
560
563
      else if ((depth <= 24) && ((bpp == 24) || (bpp == 32)))
561
564
        {
562
 
          image_ID = load_xwd_f2_d24_b32 (filename, ifp, &xwdhdr, xwdcolmap);
 
565
          image_ID = load_xwd_f2_d24_b32 (filename, ifp, &xwdhdr, xwdcolmap,
 
566
                                          error);
563
567
        }
564
568
      break;
565
569
    }
570
574
  if (xwdcolmap)
571
575
    g_free (xwdcolmap);
572
576
 
573
 
  if (image_ID == -1)
 
577
  if (image_ID == -1 && ! (error && *error))
574
578
    g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
575
579
                 _("XWD-file %s has format %d, depth %d and bits per pixel %d. "
576
580
                   "Currently this is not supported."),
1624
1628
/* Load XWD with pixmap_format 2, pixmap_depth up to 24, bits_per_pixel 24/32 */
1625
1629
 
1626
1630
static gint32
1627
 
load_xwd_f2_d24_b32 (const gchar     *filename,
1628
 
                     FILE            *ifp,
1629
 
                     L_XWDFILEHEADER *xwdhdr,
1630
 
                     L_XWDCOLOR      *xwdcolmap)
 
1631
load_xwd_f2_d24_b32 (const gchar      *filename,
 
1632
                     FILE             *ifp,
 
1633
                     L_XWDFILEHEADER  *xwdhdr,
 
1634
                     L_XWDCOLOR       *xwdcolmap,
 
1635
                     GError          **error)
1631
1636
{
1632
1637
  register guchar *dest, lsbyte_first;
1633
1638
  gint             width, height, linepad, i, j, c0, c1, c2, c3;
1652
1657
  width  = xwdhdr->l_pixmap_width;
1653
1658
  height = xwdhdr->l_pixmap_height;
1654
1659
 
1655
 
  image_ID = create_new_image (filename, width, height, GIMP_RGB,
1656
 
                               &layer_ID, &drawable, &pixel_rgn);
1657
 
 
1658
 
  tile_height = gimp_tile_height ();
1659
 
  data = g_malloc (tile_height * width * 3);
1660
 
 
1661
1660
  redmask   = xwdhdr->l_red_mask;
1662
1661
  greenmask = xwdhdr->l_green_mask;
1663
1662
  bluemask  = xwdhdr->l_blue_mask;
1685
1684
  maxblue = 0; while (bluemask >> (blueshift + maxblue)) maxblue++;
1686
1685
  maxblue = (1 << maxblue) - 1;
1687
1686
 
 
1687
  if (maxred   > sizeof (redmap)   ||
 
1688
      maxgreen > sizeof (greenmap) ||
 
1689
      maxblue  > sizeof (bluemap))
 
1690
    {
 
1691
      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
 
1692
                   _("XWD-file %s is corrupt."),
 
1693
                   gimp_filename_to_utf8 (filename));
 
1694
      return -1;
 
1695
    }
 
1696
 
 
1697
  image_ID = create_new_image (filename, width, height, GIMP_RGB,
 
1698
                               &layer_ID, &drawable, &pixel_rgn);
 
1699
 
 
1700
  tile_height = gimp_tile_height ();
 
1701
  data = g_malloc (tile_height * width * 3);
 
1702
 
1688
1703
  /* Set map-arrays for red, green, blue */
1689
1704
  for (red = 0; red <= maxred; red++)
1690
1705
    redmap[red] = (red * 255) / maxred;
1825
1840
/* Load XWD with pixmap_format 1, pixmap_depth up to 24, bits_per_pixel 1 */
1826
1841
 
1827
1842
static gint32
1828
 
load_xwd_f1_d24_b1 (const gchar     *filename,
1829
 
                    FILE            *ifp,
1830
 
                    L_XWDFILEHEADER *xwdhdr,
1831
 
                    L_XWDCOLOR      *xwdcolmap)
 
1843
load_xwd_f1_d24_b1 (const gchar      *filename,
 
1844
                    FILE             *ifp,
 
1845
                    L_XWDFILEHEADER  *xwdhdr,
 
1846
                    L_XWDCOLOR       *xwdcolmap,
 
1847
                    GError          **error)
1832
1848
{
1833
1849
  register guchar *dest, outmask, inmask, do_reverse;
1834
1850
  gint             width, height, i, j, plane, fromright;
1863
1879
  indexed         = (xwdhdr->l_pixmap_depth <= 8);
1864
1880
  bytes_per_pixel = (indexed ? 1 : 3);
1865
1881
 
1866
 
  image_ID = create_new_image (filename, width, height,
1867
 
                               indexed ? GIMP_INDEXED : GIMP_RGB,
1868
 
                               &layer_ID, &drawable, &pixel_rgn);
1869
 
 
1870
 
  tile_height = gimp_tile_height ();
1871
 
  data = g_malloc (tile_height * width * bytes_per_pixel);
1872
 
 
1873
1882
  for (j = 0; j < 256; j++)   /* Create an array for reversing bits */
1874
1883
    {
1875
1884
      inmask = 0;
1913
1922
      maxblue = 0; while (bluemask >> (blueshift + maxblue)) maxblue++;
1914
1923
      maxblue = (1 << maxblue) - 1;
1915
1924
 
 
1925
      if (maxred   > sizeof (redmap)   ||
 
1926
          maxgreen > sizeof (greenmap) ||
 
1927
          maxblue  > sizeof (bluemap))
 
1928
        {
 
1929
          g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
 
1930
                       _("XWD-file %s is corrupt."),
 
1931
                       gimp_filename_to_utf8 (filename));
 
1932
          return -1;
 
1933
        }
 
1934
 
1916
1935
      /* Set map-arrays for red, green, blue */
1917
1936
      for (red = 0; red <= maxred; red++)
1918
1937
        redmap[red] = (red * 255) / maxred;
1922
1941
        bluemap[blue] = (blue * 255) / maxblue;
1923
1942
    }
1924
1943
 
 
1944
  image_ID = create_new_image (filename, width, height,
 
1945
                               indexed ? GIMP_INDEXED : GIMP_RGB,
 
1946
                               &layer_ID, &drawable, &pixel_rgn);
 
1947
 
 
1948
  tile_height = gimp_tile_height ();
 
1949
  data = g_malloc (tile_height * width * bytes_per_pixel);
 
1950
 
1925
1951
  ncols = xwdhdr->l_colormap_entries;
1926
1952
  if (xwdhdr->l_ncolors < ncols)
1927
1953
    ncols = xwdhdr->l_ncolors;