diff --git a/ANNOUNCE b/ANNOUNCE
index b9008a1..b513cee 100644
--- a/ANNOUNCE
+++ b/ANNOUNCE
@@ -558,11 +558,14 @@
   Changed all "#if [!]defined(X)" to "if[n]def X" where possible.
   Eliminated unused png_ptr->row_buf_size
 
-version 1.4.0beta82 [September 25, 2009]
+version 1.4.0beta82 [September 24, 2009]
   Moved redundant IHDR checking into new png_check_IHDR() in png.c
     and report all errors found in the IHDR data.
   Eliminated useless call to png_check_cHRM() from pngset.c
 
+version 1.4.0beta83 [September 25, 2009]
+  Revised png_check_IHDR() to eliminate bogus complaint about filter_type.
+
 version 1.4.0betaN [future]
   Build shared libraries with -lz and sometimes -lm.
 
diff --git a/CHANGES b/CHANGES
index c49b09d..7510457 100644
--- a/CHANGES
+++ b/CHANGES
@@ -2244,11 +2244,14 @@
   Changed all "#if [!]defined(X)" to "if[n]def X" where possible.
   Eliminated unused png_ptr->row_buf_size
 
-version 1.4.0beta82 [September 25, 2009]
+version 1.4.0beta82 [September 24, 2009]
   Moved redundant IHDR checking into new png_check_IHDR() in png.c
     and report all errors found in the IHDR data.
   Eliminated useless call to png_check_cHRM() from pngset.c
 
+version 1.4.0beta83 [September 25, 2009]
+  Revised png_check_IHDR() to eliminate bogus complaint about filter_type.
+
 version 1.4.0betaN [future]
   Build shared libraries with -lz and sometimes -lm.
 
diff --git a/png.c b/png.c
index d793578..b585317 100644
--- a/png.c
+++ b/png.c
@@ -887,17 +887,22 @@
 
    if (filter_type != PNG_FILTER_TYPE_BASE)
    {
-     if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
+      if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
          (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
-         ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
+         ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
          (color_type == PNG_COLOR_TYPE_RGB ||
          color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
-        png_warning(png_ptr, "Unknown filter method in IHDR");
-      error = 1;
-   }
+      {
+         png_warning(png_ptr, "Unknown filter method in IHDR");
+         error = 1;
+      }
 
-     if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
-        png_warning(png_ptr, "Invalid filter method in IHDR");
+      if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
+      {
+         png_warning(png_ptr, "Invalid filter method in IHDR");
+         error = 1;
+      }
+   }
 
 #else
    if (filter_type != PNG_FILTER_TYPE_BASE)
diff --git a/pngpriv.h b/pngpriv.h
index bf85dfd..6ce838e 100644
--- a/pngpriv.h
+++ b/pngpriv.h
@@ -817,20 +817,20 @@
    png_fixed_point int_blue_y));
 #endif
 
+#ifdef PNG_cHRM_SUPPORTED
+#ifdef PNG_CHECK_cHRM_SUPPORTED
+/* Added at libpng version 1.2.34 and 1.4.0 */
+PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,
+   unsigned long *hi_product, unsigned long *lo_product));
+#endif
+#endif
+
 /* Added at libpng version 1.4.0 */
 PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,
    png_uint_32 width, png_uint_32 height, int bit_depth,
    int color_type, int interlace_type, int compression_type,
    int filter_type));
 
-#ifdef PNG_cHRM_SUPPORTED
-#ifdef PNG_CHECK_cHRM_SUPPORTED
-/* Added at libpng version 1.2.34 and 1.4.0 */
-PNG_EXTERN void png_64bit_product (long v1, long v2, unsigned long *hi_product,
-   unsigned long *lo_product);
-#endif
-#endif
-
 /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
 
 #ifdef __cplusplus
