looks like issue fixed

copy between imageio and pixelpipe was wrong

Author: maruncz

src/common/imageio_rawspeed.cc

@@ -512,6 +512,19 @@ dt_imageio_retval_t dt_imageio_open_rawspeed(dt_image_t *img, const char *filena
      */
     if(isMultiFrame)
     {
+      /*for(size_t f = 0; f < r.size(); ++f)
+      {
+        char *ptr = (char *)r.get(f)->getDataUncropped(0, 0);
+        int value = (((float)f+1) / ((float)(r.size()+2))) * img->raw_white_point;
+        for(int j = 0; j < dimUncropped.y; ++j)
+        {
+          uint16_t * start = (uint16_t*)(ptr + (j * r.get(f)->pitch));
+          for(int i=0;i<dimUncropped.x;++i)
+          {
+            start[i] = value;
+          }
+        }
+      }*/
       const size_t bufSize_mipmap = (size_t)img->width * img->height * img->buf_dsc.frames * r.get(0)->getBpp();
       const size_t bufSize_rawspeed = (size_t)r.get(0)->pitch * dimUncropped.y * r.size();
       const size_t frame_size = bufSize_mipmap / r.size();

src/develop/pixelpipe_hb.c

@@ -117,8 +117,29 @@ static void save_debug_bitmap(dt_dev_pixelpipe_t *pipe, const char *name, void *
     return;
   }
 
+  int single_channel = pipe->dsc.channels == 1;
+  int floating = pipe->dsc.datatype == TYPE_FLOAT;
+
+
+  char ext[8];
+  if(floating)
+  {
+    snprintf(ext,8,"pfm");
+  }
+  else
+  {
+    if(single_channel)
+    {
+      snprintf(ext,8,"pgm");
+    }
+    else
+    {
+      snprintf(ext,8,"ppm");
+    }
+  }
+
   char filename[128];
-  snprintf(filename, 128, "save_debug_bitmap_%s_%s.pfm", name, _pipe_type_to_str(pipe->type));
+  snprintf(filename, 128, "save_debug_bitmap_%s_%s.%s", name, _pipe_type_to_str(pipe->type), ext);
   for(int i = 0; i < 128; ++i)
   {
     if(filename[i] == '\0')
@@ -137,40 +158,85 @@ static void save_debug_bitmap(dt_dev_pixelpipe_t *pipe, const char *name, void *
     fprintf(stderr, "error opening debug file: %s, %s\n", filename, strerror(errno));
     return;
   }
-  if(pipe->dsc.channels > 1)
+  if(floating)
   {
-    fprintf(file, "PF\n");
+    if(!single_channel)
+    {
+      fprintf(file, "PF\n");
+    }
+    else
+    {
+      fprintf(file, "Pf\n");
+    }
   }
   else
   {
-    fprintf(file, "Pf\n");
+    if(single_channel)
+    {
+      fprintf(file, "P2\n");
+    }
+    else
+    {
+      fprintf(file, "P3\n");
+    }
   }
   fprintf(file, "%i %i\n", roi_out->width, roi_out->height * pipe->dsc.frames);
-  fprintf(file, "-1.0\n");
-  float *ptr = (float *)out;
-  if((pipe->dsc.channels == 1) || (pipe->dsc.channels == 3))
+  if(floating)
+  {
+    fprintf(file, "-1.0\n");
+  }
+  else
+  {
+    fprintf(file,"%i\n", 16384);
+  }
+  if(floating)
   {
-    for(size_t f = 0; f < pipe->dsc.frames; ++f)
+    float *ptr = (float *)out;
+    if((pipe->dsc.channels == 1) || (pipe->dsc.channels == 3))
     {
-      float *tmp = ptr + (f * roi_out->width * roi_out->height);
-      for(size_t i = 0; i < roi_out->width; ++i)
+      for(size_t f = 0; f < pipe->dsc.frames; ++f)
       {
-        for(size_t j = 0; j < roi_out->height; ++j)
+        float *tmp = ptr + (f * roi_out->width * roi_out->height);
+        for(size_t i = 0; i < roi_out->width; ++i)
         {
-          const size_t pout = j + (roi_out->height * (i));
-          fwrite(tmp + pout, sizeof(float) * pipe->dsc.channels, 1, file);
+          for(size_t j = 0; j < roi_out->height; ++j)
+          {
+            const size_t pout = j + (roi_out->height * (i));
+            fwrite(tmp + pout, sizeof(float) * pipe->dsc.channels, 1, file);
+          }
+        }
+      }
+    }
+    else
+    {
+      for(size_t i = 0; i < roi_out->height * roi_out->width * pipe->dsc.frames * pipe->dsc.channels;
+          i += pipe->dsc.channels)
+      {
+        for(size_t j = 0; j < 3; ++j)
+        {
+          fwrite(ptr + i + j, sizeof(float), 1, file);
         }
       }
     }
   }
   else
   {
-    for(size_t i = 0; i < roi_out->height * roi_out->width * pipe->dsc.frames * pipe->dsc.channels;
-        i += pipe->dsc.channels)
+    if(single_channel)
     {
-      for(size_t j = 0; j < 3; ++j)
+      uint16_t *ptr = (uint16_t *)out;
+      for(size_t f = 0; f < pipe->dsc.frames; ++f)
       {
-        fwrite(ptr + i + j, sizeof(float), 1, file);
+        uint16_t *tmp = ptr + (f * roi_out->width * roi_out->height);
+        for(size_t i = 0; i < roi_out->width; ++i)
+        {
+          for(size_t j = 0; j < roi_out->height; ++j)
+          {
+            const size_t pout = j + (roi_out->height * (i));
+            fprintf(file,"%hu ",tmp[pout]);
+            //fwrite(tmp + pout, sizeof(uint16_t), 1, file);
+          }
+          fprintf(file,"\n");
+        }
       }
     }
   }
@@ -1245,6 +1311,9 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
           const int cp_height = MIN(roi_out->height, pipe->iheight - in_y);
           const int frames = pipe->dsc.frames;
 
+          //fprintf(stderr, "[pipe] %s, input: %p\n", _pipe_type_to_str(pipe->type), pipe->input);
+          //fprintf(stderr, "[pipe] %s, output: %p\n", _pipe_type_to_str(pipe->type), *output);
+
           if (cp_width > 0)
           {
 #ifdef _OPENMP
@@ -1253,10 +1322,18 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
           shared(pipe, roi_out, roi_in, output) \
           schedule(static)
 #endif
-            for(int j = 0; j < cp_height * frames; j++)
-              memcpy(((char *)*output) + (size_t)bpp * j * roi_out->width,
-                     ((char *)pipe->input) + (size_t)bpp * (in_x + (in_y + j) * pipe->iwidth),
-                     (size_t)bpp * cp_width);
+            for(int f = 0; f < frames; ++f)
+            {
+              char *ptr = ((char *)pipe->input) + (f * bpp * pipe->iheight * pipe->iwidth);
+              char *outptr = ((char *)*output) + (f * bpp * roi_out->height * roi_out->width);
+              for(int j = 0; j < cp_height; j++)
+                memcpy(outptr + (size_t)bpp * j * roi_out->width,
+                       ptr + (size_t)bpp * (in_x + (in_y + j) * pipe->iwidth), (size_t)bpp * cp_width);
+            }
+
+#ifdef DEBUG_PIXELPIPE
+            save_debug_bitmap(pipe,"load",*output,roi_out);
+#endif
           }
         }
         else
@@ -1303,6 +1380,8 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
                                   g_list_previous(modules), g_list_previous(pieces), pos - 1))
     return 1;
 
+  //fprintf(stderr,"[pipe] %s, module: %s, input: %p\n",_pipe_type_to_str(pipe->type), module->op ,input);
+
   const size_t in_bpp = dt_iop_buffer_dsc_to_bpp(input_format);
 
   piece->dsc_out = piece->dsc_in = *input_format;
@@ -1332,6 +1411,8 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
 // if(module) printf("reserving new buf in cache for module %s %s: %ld buf %p\n", module->op, pipe ==
 // dev->preview_pipe ? "[preview]" : "", hash, *output);
 
+  //fprintf(stderr,"[pipe] %s, module: %s, output: %p\n",_pipe_type_to_str(pipe->type), module->op ,*output);
+
   if(dt_atomic_get_int(&pipe->shutdown))
   {
     return 1;
@@ -1982,6 +2063,7 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
       return 1;
   }
 #else // HAVE_OPENCL
+
   if (pixelpipe_process_on_CPU(pipe, dev, input, input_format, &roi_in, output, out_format, roi_out,
                                module, piece, &tiling, &pixelpipe_flow))
     return 1;

src/iop/demosaic.c

@@ -2995,7 +2995,7 @@ void process_pixelshift(dt_dev_pixelpipe_iop_t *piece, const float *const in, fl
       }
     }
   }
-  fprintf(stderr,"pout: %lu\n", pout+4);
+  //fprintf(stderr,"pout: %lu\n", pout+4);
 }
 
 

src/iop/rawprepare.c

@@ -275,7 +275,7 @@ static void convert_uint_float(const uint16_t *const in, float *const out, const
     dt_omp_firstprivate(csx, csy, d, in, out, roi_in, roi_out)          \
     schedule(static) collapse(2)
 #endif
-  for(int j = 0; j < roi_out->height-100; j++)
+  for(int j = 0; j < roi_out->height; j++)
   {
     for(int i = 0; i < roi_out->width; i++)
     {
@@ -287,7 +287,7 @@ static void convert_uint_float(const uint16_t *const in, float *const out, const
     }
   }
 
-  for(int j = roi_out->height-100; j < roi_out->height; j++)
+  /*for(int j = roi_out->height-100; j < roi_out->height; j++)
   {
     for(int i = 0; i < roi_out->width; i++)
     {
@@ -297,7 +297,7 @@ static void convert_uint_float(const uint16_t *const in, float *const out, const
 
       out[pout] = 0.0f;
     }
-  }
+  }*/
 }
 
 static void convert_float_float(const float *const in, float *const out, const dt_iop_roi_t *const roi_in,
@@ -355,13 +355,13 @@ void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const
 {
   const dt_iop_rawprepare_data_t *const d = (dt_iop_rawprepare_data_t *)piece->data;
 
-  fprintf(stderr,"rawprepare %s\n", dt_pixelpipe_name(piece->pipe->type));
-  fprintf(stderr, "roi in %d %d %d %d\n", roi_in->x, roi_in->y, roi_in->width, roi_in->height);
-  fprintf(stderr, "roi out %d %d %d %d\n", roi_out->x, roi_out->y, roi_out->width, roi_out->height);
+  //fprintf(stderr,"rawprepare %s\n", dt_pixelpipe_name(piece->pipe->type));
+  //fprintf(stderr, "roi in %d %d %d %d\n", roi_in->x, roi_in->y, roi_in->width, roi_in->height);
+  //fprintf(stderr, "roi out %d %d %d %d\n", roi_out->x, roi_out->y, roi_out->width, roi_out->height);
   /*fprintf(stderr,"frame size in:  %d\n", roi_in->width * roi_in->height);
   fprintf(stderr,"frame size iout: %d\n", roi_out->width * roi_out->height);*/
-  fprintf(stderr,"i: %p\n",ivoid);
-  fprintf(stderr,"o: %p\n",ovoid);
+  //fprintf(stderr,"i: %p\n",ivoid);
+  //fprintf(stderr,"o: %p\n",ovoid);
 
   const int csx = compute_proper_crop(piece, roi_in, d->x);
   const int csy = compute_proper_crop(piece, roi_in, d->y);
@@ -378,11 +378,7 @@ void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const
       const uint16_t *const frame_in = in + (f * roi_in->width * roi_in->height);
       float *const frame_out = out + (f * roi_out->width * roi_out->height);
       convert_uint_float(frame_in, frame_out, roi_in, roi_out, csx, csy, d);
-      fprintf(stderr, "frame %lu: %p\n", f, frame_in);
-      /*for(size_t i=0;i<roi_out->width * roi_out->height;++i)
-      {
-        frame_out[i] = (float)f / (float)piece->dsc_out.frames;
-      }*/
+      //fprintf(stderr, "frame %lu: %p\n", f, frame_in);
     }
 
     piece->pipe->dsc.filters = dt_rawspeed_crop_dcraw_filters(self->dev->image_storage.buf_dsc.filters, csx, csy);