# HG changeset patch
# User magedrifaat <magedrifaat@gmail.com>
# Date 1660833596 -7200
# Node ID 86f91ea7a64288ef6ac1ad3752bff198a9c2000f
# Parent  6ab628dfe2a0cda703280b4ee6d6aa586f9be67c
__tiff__.cc (get_field_data): fixed return type for some tags.

diff -r 6ab628dfe2a0 -r 86f91ea7a642 libinterp/corefcn/__tiff__.cc
--- a/libinterp/corefcn/__tiff__.cc	Thu Aug 18 15:59:33 2022 +0200
+++ b/libinterp/corefcn/__tiff__.cc	Thu Aug 18 16:39:56 2022 +0200
@@ -962,63 +962,6 @@
       }
   }
 
-  octave_value
-  interpret_scalar_tag_data (void *data, TIFFDataType tag_datatype)
-  {
-    double retval;
-
-    switch (tag_datatype)
-      {
-      case TIFF_BYTE:
-      case TIFF_UNDEFINED:
-        retval = static_cast<double> (*(reinterpret_cast<uint8_t *> (data)));
-        break;
-      case TIFF_SHORT:
-        retval = static_cast<double> (*(reinterpret_cast<uint16_t *> (data)));
-        break;
-      case TIFF_LONG:
-        retval = static_cast<double> (*(reinterpret_cast<uint32_t *> (data)));
-        break;
-      case TIFF_LONG8:
-        retval = static_cast<double> (*(reinterpret_cast<uint64_t *> (data)));
-        break;
-      case TIFF_RATIONAL:
-        retval = *(reinterpret_cast<float *> (data));
-        break;
-      case TIFF_SBYTE:
-        retval = static_cast<double> (*(reinterpret_cast<int8_t *> (data)));
-        break;
-      case TIFF_SSHORT:
-        retval = static_cast<double> (*(reinterpret_cast<int16_t *> (data)));
-        break;
-      case TIFF_SLONG:
-        retval = static_cast<double> (*(reinterpret_cast<int32_t *> (data)));
-        break;
-      case TIFF_SLONG8:
-        retval = static_cast<double> (*(reinterpret_cast<int64_t *> (data)));
-        break;
-      case TIFF_FLOAT:
-        retval = *(reinterpret_cast<float *> (data));
-        break;
-      case TIFF_DOUBLE:
-        retval = *(reinterpret_cast<double *> (data));
-        break;
-      case TIFF_SRATIONAL:
-        retval = *(reinterpret_cast<float *> (data));
-        break;
-      case TIFF_IFD:
-        retval = static_cast<double> (*(reinterpret_cast<uint32_t *> (data)));
-        break;
-      case TIFF_IFD8:
-        retval = static_cast<double> (*(reinterpret_cast<uint64_t *> (data)));
-        break;
-      default:
-        error ("Unsupported tag data type");
-      }
-
-    return octave_value (retval);
-  }
-
   template <typename T>
   octave_value
   make_array (void *data, dim_vector& arr_dims)
@@ -1034,89 +977,78 @@
   }
 
   octave_value
-  interpret_tag_data (void *data, uint32_t count, TIFFDataType tag_datatype)
+  interpret_tag_data (void *data, uint32_t count, TIFFDataType tag_datatype,
+                      bool convert_to_double = false)
   {
-    octave_value retval;
-    // Apparently matlab converts scalar numerical values into double
-    // but doesn't do the same for arrays
-    // TODO(maged): matlab returns double for array tags as well, except
-    // for a selected set of tags (e.g. StripByteCounts)
-    
-    if (count == 1 && tag_datatype != TIFF_ASCII)
-      {
-        retval = interpret_scalar_tag_data (data, tag_datatype);
-      }
-    else
+    octave_value retval;dim_vector arr_dims (1, count);
+    switch (tag_datatype)
       {
-        dim_vector arr_dims (1, count);
-
-        switch (tag_datatype)
-          {
-          case TIFF_BYTE:
-          case TIFF_UNDEFINED:
-            {
-              retval = make_array<uint8NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_ASCII:
-            {
-              retval = octave_value (*(reinterpret_cast<char **> (data)));
-              break;
-            }
-          case TIFF_SHORT:
-            {
-              retval = make_array<uint16NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_LONG:
-          case TIFF_IFD:
-            {
-              retval = make_array<uint32NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_LONG8:
-          case TIFF_IFD8:
-            {
-              retval = make_array<uint64NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_RATIONAL:
-          case TIFF_SRATIONAL:
-          case TIFF_FLOAT:
-            {
-              retval = make_array<FloatNDArray> (data, arr_dims).as_double ();
-              break;
-            }
-          case TIFF_SBYTE:
-            {
-              retval = make_array<int8NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_SSHORT:
-            {
-              retval = make_array<int16NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_SLONG:
-            {
-              retval = make_array<int32NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_SLONG8:
-            {
-              retval = make_array<int64NDArray> (data, arr_dims);
-              break;
-            }
-          case TIFF_DOUBLE:
-            {
-              retval = make_array<NDArray> (data, arr_dims);
-              break;
-            }
-          default:
-            error ("Unsupported tag data type");
-          }
+      case TIFF_BYTE:
+      case TIFF_UNDEFINED:
+        {
+          retval = make_array<uint8NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_ASCII:
+        {
+          retval = octave_value (*(reinterpret_cast<char **> (data)));
+          break;
+        }
+      case TIFF_SHORT:
+        {
+          retval = make_array<uint16NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_LONG:
+      case TIFF_IFD:
+        {
+          retval = make_array<uint32NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_LONG8:
+      case TIFF_IFD8:
+        {
+          retval = make_array<uint64NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_RATIONAL:
+      case TIFF_SRATIONAL:
+      case TIFF_FLOAT:
+        {
+          retval = make_array<FloatNDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_SBYTE:
+        {
+          retval = make_array<int8NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_SSHORT:
+        {
+          retval = make_array<int16NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_SLONG:
+        {
+          retval = make_array<int32NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_SLONG8:
+        {
+          retval = make_array<int64NDArray> (data, arr_dims);
+          break;
+        }
+      case TIFF_DOUBLE:
+        {
+          retval = make_array<NDArray> (data, arr_dims);
+          break;
+        }
+      default:
+        error ("Unsupported tag data type");
       }
 
+    if (tag_datatype != TIFF_ASCII && convert_to_double)
+      retval = retval.as_double ();
     return retval;
   }
 
@@ -1147,19 +1079,23 @@
     else
       validate_tiff_get_field (TIFFGetFieldDefaulted (tif, tag_id, data_ptr));
     
+    // All scalar tags are returned as double
     octave_value tag_data_ov = interpret_tag_data (data_ptr, 1,
-                                                   TIFFFieldDataType (fip));
+                                                   TIFFFieldDataType (fip),
+                                                   true);
 
     return tag_data_ov;
   }
 
   octave_value
-  get_array_field_data (TIFF *tif, const TIFFField *fip, uint32_t array_size)
+  get_array_field_data (TIFF *tif, const TIFFField *fip, uint32_t array_size,
+                        bool convert_to_double = false)
   {
     void *data;
     validate_tiff_get_field (TIFFGetField (tif, TIFFFieldTag (fip), &data));
       
-    return interpret_tag_data (data, array_size, TIFFFieldDataType (fip));
+    return interpret_tag_data (data, array_size, TIFFFieldDataType (fip),
+                               convert_to_double);
   }
 
   octave_value
@@ -1182,10 +1118,10 @@
           = get_array_field_data (tif, fip, TIFFNumberOfTiles (tif));
         break;
       case TIFFTAG_YCBCRCOEFFICIENTS:
-        tag_data_ov = get_array_field_data (tif, fip, 3);
+        tag_data_ov = get_array_field_data (tif, fip, 3, true);
         break;
       case TIFFTAG_REFERENCEBLACKWHITE:
-        tag_data_ov = get_array_field_data (tif, fip, 6);
+        tag_data_ov = get_array_field_data (tif, fip, 6, true);
         break;
       case TIFFTAG_GRAYRESPONSECURVE:
         {
@@ -1194,7 +1130,8 @@
                                             &bits_per_sample))
             error ("Failed to obtain the bit depth");
           
-          tag_data_ov = get_array_field_data (tif, fip, 1<<bits_per_sample);
+          tag_data_ov = get_array_field_data (tif, fip,
+                                              1<<bits_per_sample, true);
           break;
         }
       case TIFFTAG_COLORMAP:
@@ -1262,30 +1199,30 @@
                                                  &ch1, &ch2, &ch3));
           if (ch2 == NULL)
             tag_data_ov = interpret_tag_data (ch1, count,
-                                              TIFFFieldDataType (fip));
+                                              TIFFFieldDataType (fip), true);
           else
             {
               // Concatenate the channels into an n by 3 array
-              OCTAVE_LOCAL_BUFFER (uint16NDArray, array_list, 3);
+              OCTAVE_LOCAL_BUFFER (NDArray, array_list, 3);
               dim_vector col_dims(count, 1);
               array_list[0] = interpret_tag_data (ch1,
                                                   count,
                                                   TIFFFieldDataType (fip))
-                                                  .uint16_array_value ()
+                                                  .array_value ()
                                                   .reshape (col_dims);
               array_list[1] = interpret_tag_data (ch2,
                                                   count,
                                                   TIFFFieldDataType (fip))
-                                                  .uint16_array_value ()
+                                                  .array_value ()
                                                   .reshape (col_dims);
               array_list[2] = interpret_tag_data (ch3,
                                                   count,
                                                   TIFFFieldDataType (fip))
-                                                  .uint16_array_value ()
+                                                  .array_value ()
                                                   .reshape (col_dims);
               
               tag_data_ov
-                = octave_value (uint16NDArray::cat (1, 3, array_list));
+                = octave_value (NDArray::cat (1, 3, array_list));
             }
           break;
         }