Revert "Security patch from Claude Code."

This reverts commit fdc1e0e.

Author: TurboGit

src/common/curve_tools.c

@@ -664,7 +664,6 @@ float spline_cubic_val(int n, float t[], float tval, float y[], float ypp[])
 int CurveDataSample(CurveData *curve, CurveSample *sample)
 {
   int n = 0;
-  const int num_anchors = curve->m_numAnchors > MAX_ANCHORS ? MAX_ANCHORS : curve->m_numAnchors;
 
   float x[20] = { 0 };
   float y[20] = { 0 };
@@ -687,12 +686,12 @@ int CurveDataSample(CurveData *curve, CurveSample *sample)
   }
   else
   {
-    for(int i = 0; i < num_anchors; i++)
+    for(int i = 0; i < curve->m_numAnchors; i++)
     {
       x[i] = curve->m_anchors[i].x * box_width + curve->m_min_x;
       y[i] = curve->m_anchors[i].y * box_height + curve->m_min_y;
     }
-    n = num_anchors;
+    n = curve->m_numAnchors;
   }
   const float res = 1.0 / (float)(sample->m_samplingRes - 1);
   const int firstPointX = x[0] * (sample->m_samplingRes - 1);
@@ -742,3 +741,4 @@ int CurveDataSample(CurveData *curve, CurveSample *sample)
 // vim: shiftwidth=2 expandtab tabstop=2 cindent
 // kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
 // clang-format on
+

src/common/spektra_sim.c

@@ -2451,8 +2451,6 @@ static void _sf_morph_channel(const double centers_in[],
                               double sigmas_out[],
                               double gumbel_mix_out[])
 {
-  if(nl <= 0) return;
-
   int order[SF_GRAIN_MAX_SUBLAYERS];
   for(int i = 0; i < nl; i++) order[i] = i;
   for(int i = 0; i < nl; i++)

src/gui/draw.h

@@ -628,7 +628,6 @@ static inline void dt_draw_curve_set_point(dt_draw_curve_t *c,
                                            const float x,
                                            const float y)
 {
-  if(num < 0 || num >= MAX_ANCHORS) return;
   c->c.m_anchors[num].x = x;
   c->c.m_anchors[num].y = y;
 }
@@ -709,20 +708,19 @@ static inline void dt_draw_curve_calc_values_V2(dt_draw_curve_t *c,
 
 static inline float dt_draw_curve_calc_value(dt_draw_curve_t *c, const float x)
 {
-  float xa[MAX_ANCHORS], ya[MAX_ANCHORS];
+  float xa[20], ya[20];
   float val = 0.f;
   float *ypp = NULL;
-  const int num_anchors = MIN((int)c->c.m_numAnchors, MAX_ANCHORS);
 
-  for(int i = 0; i < num_anchors; i++)
+  for(int i = 0; i < c->c.m_numAnchors; i++)
   {
     xa[i] = c->c.m_anchors[i].x;
     ya[i] = c->c.m_anchors[i].y;
   }
-  ypp = interpolate_set(num_anchors, xa, ya, c->c.m_spline_type);
+  ypp = interpolate_set(c->c.m_numAnchors, xa, ya, c->c.m_spline_type);
   if(ypp)
   {
-    val = interpolate_val(num_anchors, xa, x, ya, ypp, c->c.m_spline_type);
+    val = interpolate_val(c->c.m_numAnchors, xa, x, ya, ypp, c->c.m_spline_type);
     free(ypp);
   }
   return MIN(MAX(val, c->c.m_min_y), c->c.m_max_y);
@@ -732,7 +730,6 @@ static inline void dt_draw_curve_add_point(dt_draw_curve_t *c,
                                           const float x,
                                           const float y)
 {
-  if(c->c.m_numAnchors >= MAX_ANCHORS) return;
   c->c.m_anchors[c->c.m_numAnchors].x = x;
   c->c.m_anchors[c->c.m_numAnchors].y = y;
   c->c.m_numAnchors++;

src/iop/ashift.c

@@ -3123,24 +3123,23 @@ static gboolean _draw_retrieve_lines_from_params(dt_iop_module_t *self,
     }
   }
 
-  const int count = CLAMP(p->last_drawn_lines_count, 0, MAX_SAVED_LINES);
-  if(method == ASHIFT_METHOD_LINES && count > 0)
+  if(method == ASHIFT_METHOD_LINES && p->last_drawn_lines_count > 0)
   {
     float pts[MAX_SAVED_LINES * 4] = { 0.0f };
 
-    for(int i = 0; i < count * 4; i++)
+    for(int i = 0; i < p->last_drawn_lines_count * 4; i++)
       pts[i] = p->last_drawn_lines[i];
 
     if(dt_dev_distort_transform_plus(self->dev, self->dev->preview_pipe, self->iop_order,
                                      DT_DEV_TRANSFORM_DIR_BACK_EXCL, pts,
-                                     count * 2))
+                                     p->last_drawn_lines_count * 2))
     {
       if(g->lines) free(g->lines);
-      g->lines = calloc(count, sizeof(dt_iop_ashift_line_t));
+      g->lines = calloc(p->last_drawn_lines_count, sizeof(dt_iop_ashift_line_t));
 
       int vnb = 0; // number of vertical lines
       int hnb = 0; // number of horizontal lines
-      for(int i = 0; i < count; i++)
+      for(int i = 0; i < p->last_drawn_lines_count; i++)
       {
         // determine if the line is vertical or horizontal
         dt_iop_ashift_linetype_t linetype = ASHIFT_LINE_VERTICAL_SELECTED;
@@ -3157,7 +3156,7 @@ static gboolean _draw_retrieve_lines_from_params(dt_iop_module_t *self,
           hnb++;
       }
 
-      g->lines_count = count;
+      g->lines_count = p->last_drawn_lines_count;
       g->vertical_count = vnb;
       g->horizontal_count = hnb;
       g->vertical_weight = (float)vnb;

src/iop/basecurve.c

@@ -73,11 +73,6 @@ typedef struct dt_iop_basecurve_params_t
   dt_iop_rgb_norms_t preserve_colors; /* $DEFAULT: DT_RGB_NORM_LUMINANCE $DESCRIPTION: "preserve colors" */
 } dt_iop_basecurve_params_t;
 
-static inline int _basecurve_nodes(const int nodes)
-{
-  return CLAMP(nodes, 0, MAXNODES);
-}
-
 int legacy_params(dt_iop_module_t *self,
                   const void *const old_params,
                   const int old_version,
@@ -1414,16 +1409,15 @@ void commit_params(dt_iop_module_t *self,
   d->preserve_colors = p->preserve_colors;
 
   const int ch = 0;
-  const int nodes = _basecurve_nodes(p->basecurve_nodes[ch]);
   // take care of possible change of curve type or number of nodes (not yet implemented in UI)
-  if(d->basecurve_type != p->basecurve_type[ch] || d->basecurve_nodes != nodes)
+  if(d->basecurve_type != p->basecurve_type[ch] || d->basecurve_nodes != p->basecurve_nodes[ch])
   {
     if(d->curve) // catch initial init_pipe case
       dt_draw_curve_destroy(d->curve);
     d->curve = dt_draw_curve_new(0.0, 1.0, p->basecurve_type[ch]);
-    d->basecurve_nodes = nodes;
+    d->basecurve_nodes = p->basecurve_nodes[ch];
     d->basecurve_type = p->basecurve_type[ch];
-    for(int k = 0; k < nodes; k++)
+    for(int k = 0; k < p->basecurve_nodes[ch]; k++)
     {
       // printf("p->basecurve[%i][%i].x = %f;\n", ch, k, p->basecurve[ch][k].x);
       // printf("p->basecurve[%i][%i].y = %f;\n", ch, k, p->basecurve[ch][k].y);
@@ -1432,13 +1426,13 @@ void commit_params(dt_iop_module_t *self,
   }
   else
   {
-    for(int k = 0; k < nodes; k++)
+    for(int k = 0; k < p->basecurve_nodes[ch]; k++)
       dt_draw_curve_set_point(d->curve, k, p->basecurve[ch][k].x, p->basecurve[ch][k].y);
   }
   dt_draw_curve_calc_values(d->curve, 0.0f, 1.0f, 0x10000, NULL, d->table);
 
   // now the extrapolation stuff:
-  const float xm = p->basecurve[0][MAX(1, nodes) - 1].x;
+  const float xm = p->basecurve[0][p->basecurve_nodes[0] - 1].x;
   const float x[4] = { 0.7f * xm, 0.8f * xm, 0.9f * xm, 1.0f * xm };
   const float y[4] = { d->table[CLAMP((int)(x[0] * 0x10000ul), 0, 0xffff)],
                        d->table[CLAMP((int)(x[1] * 0x10000ul), 0, 0xffff)],
@@ -1566,27 +1560,27 @@ static gboolean dt_iop_basecurve_draw(GtkWidget *widget, cairo_t *crf, dt_iop_mo
   dt_iop_basecurve_gui_data_t *g = self->gui_data;
   dt_iop_basecurve_params_t *p = self->params;
 
-  const int nodes = _basecurve_nodes(p->basecurve_nodes[0]);
+  int nodes = p->basecurve_nodes[0];
   dt_iop_basecurve_node_t *basecurve = p->basecurve[0];
-  if(g->minmax_curve_type != p->basecurve_type[0] || g->minmax_curve_nodes != nodes)
+  if(g->minmax_curve_type != p->basecurve_type[0] || g->minmax_curve_nodes != p->basecurve_nodes[0])
   {
     dt_draw_curve_destroy(g->minmax_curve);
     g->minmax_curve = dt_draw_curve_new(0.0, 1.0, p->basecurve_type[0]);
-    g->minmax_curve_nodes = nodes;
+    g->minmax_curve_nodes = p->basecurve_nodes[0];
     g->minmax_curve_type = p->basecurve_type[0];
-    for(int k = 0; k < nodes; k++)
+    for(int k = 0; k < p->basecurve_nodes[0]; k++)
       (void)dt_draw_curve_add_point(g->minmax_curve, p->basecurve[0][k].x, p->basecurve[0][k].y);
   }
   else
   {
-    for(int k = 0; k < nodes; k++)
+    for(int k = 0; k < p->basecurve_nodes[0]; k++)
       dt_draw_curve_set_point(g->minmax_curve, k, p->basecurve[0][k].x, p->basecurve[0][k].y);
   }
   dt_draw_curve_t *minmax_curve = g->minmax_curve;
   dt_draw_curve_calc_values(minmax_curve, 0.0, 1.0, DT_IOP_TONECURVE_RES, g->draw_xs, g->draw_ys);
 
   float unbounded_coeffs[3];
-  const float xm = basecurve[MAX(1, nodes) - 1].x;
+  const float xm = basecurve[nodes - 1].x;
   {
     const float x[4] = { 0.7f * xm, 0.8f * xm, 0.9f * xm, 1.0f * xm };
     const float y[4] = { g->draw_ys[CLAMP((int)(x[0] * DT_IOP_TONECURVE_RES), 0, DT_IOP_TONECURVE_RES - 1)],
@@ -1620,7 +1614,7 @@ static gboolean dt_iop_basecurve_draw(GtkWidget *widget, cairo_t *crf, dt_iop_mo
   cairo_fill(cr);
 
   cairo_translate(cr, 0, height);
-  if(g->selected >= 0 && g->selected < nodes)
+  if(g->selected >= 0)
   {
     char text[30];
     // draw information about current selected node
@@ -1676,7 +1670,7 @@ static gboolean dt_iop_basecurve_draw(GtkWidget *widget, cairo_t *crf, dt_iop_mo
   // draw selected cursor
   cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.));
 
-  if(g->selected >= 0 && g->selected < nodes)
+  if(g->selected >= 0)
   {
     cairo_set_source_rgb(cr, .9, .9, .9);
     const float x = to_log(basecurve[g->selected].x, g->loglogscale),
@@ -1750,10 +1744,10 @@ static void dt_iop_basecurve_sanity_check(dt_iop_module_t *self, GtkWidget *widg
   dt_iop_basecurve_params_t *p = self->params;
 
   int ch = 0;
-  const int nodes = _basecurve_nodes(p->basecurve_nodes[ch]);
+  int nodes = p->basecurve_nodes[ch];
   dt_iop_basecurve_node_t *basecurve = p->basecurve[ch];
 
-  if(g->selected < 0 || g->selected >= nodes || nodes <= 2) return;
+  if(nodes <= 2) return;
 
   const float mx = basecurve[g->selected].x;
 
@@ -1769,7 +1763,7 @@ static void dt_iop_basecurve_sanity_check(dt_iop_module_t *self, GtkWidget *widg
       basecurve[k].y = basecurve[k + 1].y;
     }
     g->selected = -2; // avoid re-insertion of that point immediately after this
-    p->basecurve_nodes[ch] = nodes - 1;
+    p->basecurve_nodes[ch]--;
   }
 }
 
@@ -1788,7 +1782,7 @@ static void dt_iop_basecurve_motion_notify(GtkEventControllerMotion *controller,
   dt_iop_basecurve_gui_data_t *g = self->gui_data;
   dt_iop_basecurve_params_t *p = self->params;
   int ch = 0;
-  int nodes = _basecurve_nodes(p->basecurve_nodes[ch]);
+  int nodes = p->basecurve_nodes[ch];
   dt_iop_basecurve_node_t *basecurve = p->basecurve[ch];
 
   GtkAllocation allocation;
@@ -1804,8 +1798,6 @@ static void dt_iop_basecurve_motion_notify(GtkEventControllerMotion *controller,
   const float my = 1.0f - CLAMP(g->mouse_y, 0, height) / (float)height;
   const float linx = to_lin(mx, g->loglogscale), liny = to_lin(my, g->loglogscale);
 
-  if(g->selected >= nodes) g->selected = -1;
-
   if(dt_key_modifier_state() & GDK_BUTTON1_MASK)
   {
     // got a vertex selected:
@@ -1825,7 +1817,6 @@ static void dt_iop_basecurve_motion_notify(GtkEventControllerMotion *controller,
     else if(nodes < MAXNODES && g->selected >= -1)
     {
       // no vertex was close, create a new one!
-      p->basecurve_nodes[ch] = nodes;
       g->selected = _add_node(basecurve, &p->basecurve_nodes[ch], linx, liny);
       dt_dev_add_history_item_target(darktable.develop, self, TRUE, widget);
     }
@@ -1865,7 +1856,7 @@ static void dt_iop_basecurve_button_press(GtkGestureSingle *gesture,
   dt_iop_basecurve_gui_data_t *g = self->gui_data;
 
   int ch = 0;
-  int nodes = _basecurve_nodes(p->basecurve_nodes[ch]);
+  int nodes = p->basecurve_nodes[ch];
   dt_iop_basecurve_node_t *basecurve = p->basecurve[ch];
 
   if(gtk_gesture_single_get_current_button(gesture) == GDK_BUTTON_PRIMARY)
@@ -1911,7 +1902,6 @@ static void dt_iop_basecurve_button_press(GtkGestureSingle *gesture,
         if(curve_y >= 0.0 && curve_y <= 1.0) // never add something outside the viewport, you couldn't change it afterwards
         {
           // create a new node
-          p->basecurve_nodes[ch] = nodes;
           selected = _add_node(basecurve, &p->basecurve_nodes[ch], linx, curve_y);
 
           // maybe set the new one as being selected
@@ -1944,13 +1934,11 @@ static void dt_iop_basecurve_button_press(GtkGestureSingle *gesture,
       gtk_widget_queue_draw(GTK_WIDGET(g->area));
     }
   }
-  else if(gtk_gesture_single_get_current_button(gesture) == GDK_BUTTON_SECONDARY
-          && g->selected >= 0 && g->selected < nodes)
+  else if(gtk_gesture_single_get_current_button(gesture) == GDK_BUTTON_SECONDARY && g->selected >= 0)
   {
     // consume the event so it does not bubble to the module body's
     // right-click handler (which opens the presets menu)
     dt_gui_claim(gesture);
-    p->basecurve_nodes[ch] = nodes;
 
     if(g->selected == 0 || g->selected == nodes - 1)
     {
@@ -1968,7 +1956,7 @@ static void dt_iop_basecurve_button_press(GtkGestureSingle *gesture,
     }
     basecurve[nodes - 1].x = basecurve[nodes - 1].y = 0;
     g->selected = -2; // avoid re-insertion of that point immediately after this
-    p->basecurve_nodes[ch] = nodes - 1;
+    p->basecurve_nodes[ch]--;
     gtk_widget_queue_draw(GTK_WIDGET(g->area));
     dt_dev_add_history_item_target(darktable.develop, self, TRUE, widget);
   }
@@ -1984,8 +1972,6 @@ static gboolean _move_point_internal(dt_iop_module_t *self,
   dt_iop_basecurve_gui_data_t *g = self->gui_data;
 
   const int ch = 0;
-  const int nodes = _basecurve_nodes(p->basecurve_nodes[ch]);
-  if(g->selected < 0 || g->selected >= nodes) return FALSE;
   dt_iop_basecurve_node_t *basecurve = p->basecurve[ch];
 
   const float multiplier = dt_accel_get_speed_multiplier(widget, state);