src/dac_cam.c

   1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 c-style: "K&R" -*- */
   2
   3 /*----------------------------------------------------------------------
   4
   5   gpiv - Graphic program for Particle Image Velocimetry, based on gtk/gnome
   6           libraries.
   7
   8    Copyright (C) 2005, 2006, 2007, 2008
   9    Gerber van der Graaf <gerber_graaf@users.sourceforge.net>
  10
  11    This file is part of gpiv.
  12
  13    Gpiv is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 2, or (at your option)
  16    any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software Foundation,
  25    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26
  27 ----------------------------------------------------------------------*/
  28
  29 /*
  30  * functions for dac_cam
  31  * $Log: dac_cam.c,v $
  32  * Revision 1.7  2008-04-28 12:00:57  gerber
  33  * hdf-formatted files are now with .hdf extension (previously: .gpi)
  34  *
  35  * Revision 1.6  2007-12-19 08:42:35  gerber
  36  * debugged
  37  *
  38  * Revision 1.5  2007-11-23 16:24:07  gerber
  39  * release 0.5.0: Kafka
  40  *
  41  * Revision 1.4  2007-06-06 17:00:48  gerber
  42  * Retreives images/data from URI using Gnome Virtual File System.
  43  *
  44  * Revision 1.3  2007-03-22 16:00:32  gerber
  45  * Added image processing tabulator
  46  *
  47  * Revision 1.2  2007-01-29 11:27:43  gerber
  48  * added image formats png, gif, tif png, bmp, improved buffer display
  49  *
  50  * Revision 1.1  2006-09-18 07:29:49  gerber
  51  * Split up of triggering and image recording (camera)
  52  *
  53  */
  54 #ifdef ENABLE_CAM
  55
  56 #include <pthread.h>
  57 #include "gpiv_gui.h"
  58 #include "utils.h"
  59 #include "console.h"
  60 #include "dac_cam.h"
  61 #include "display.h"
  62 #include <libdc1394/dc1394_control.h>
  63
  64 static struct tm *dac_time;
  65 static GDate *date;
  66
  67 pthread_mutex_t mutex_rec = PTHREAD_MUTEX_INITIALIZER;
  68
  69
  70 typedef struct _ImgFrame ImgFrame;
  71 struct _ImgFrame {
  72     unsigned char **A;
  73     unsigned char **B;
  74 /*     gint count; */
  75 };
  76
  77 /*
  78  * Prototypes of local functions
  79  */
  80 static void
  81 rec_frame(ImgFrame *img_frame
  82           );
  83
  84 static void
  85 thread_rec_frame(void *img_frame
  86                  );
  87
  88 static void
  89 thread_rec_frame_serie(ImgFrame img_frame[GPIV_NIMG_MAX]
  90                        );
  91
  92 static void
  93 add_buffer(GpivConsole *gpiv,
  94            gchar *fname_base,
  95            gint ibuf,
  96            unsigned char **frameA,
  97            unsigned char **frameB
  98            );
  99
 100 static void
 101 renew_buffer(GpivConsole *gpiv,
 102              gchar *fname_base,
 103              gint ibuf,
 104              unsigned char **frameA,
 105              unsigned char **frameB
 106              );
 107
 108 static void
 109 recreate_img(Display * disp,
 110              unsigned char **frameA,
 111              unsigned char **frameB
 112              );
 113
 114
 115 static int
 116 open_dac_img(GpivCamVar *cam_var,
 117              unsigned char **frameA,
 118              unsigned char **frameB,
 119              Image * img,
 120              gboolean alloc_mem
 121              );
 122
 123 static void
 124 load_dac_buffer(GpivConsole *gpiv,
 125                 GpivCamVar *cam_var,
 126                 gboolean second_image,
 127                 char *fname,
 128                 int ibuf,
 129                 unsigned char **frameA,
 130                 unsigned char **frameB,
 131                 enum ClistPut clist_put
 132                 );
 133
 134 static void
 135 rec_and_display(GpivConsole *gpiv
 136                 );
 137
 138 /*
 139  * Global functions
 140  */
 141 void
 142 exec_cam_start(GpivConsole * gpiv
 143                )
 144 /*-----------------------------------------------------------------------------
 145  */
 146 {
 147 /*
 148  * dc1394 stuff
 149  */
 150 /*     quadlet_t value; */
 151
 152    cancel_process = FALSE;
 153
 154 /*
 155  * report camera's feature set
 156  * in: on_menu_camera_select
 157  */
 158 /*         dc1394_print_feature_set(&cam_var->feature_set[0]); */
 159
 160 /*    g_message("exec_cam_start:: mode[%d] = %s", */
 161 /*              cam_var->misc_info[0].mode, */
 162 /*              format0_desc[cam_var->misc_info[0].mode - MODE_FORMAT0_MIN]); */
 163 /*    g_message("exec_cam_start:: format[%d] = %s", */
 164 /*              cam_var->misc_info[0].format,  */
 165 /*              format_desc[cam_var->misc_info[0].format - FORMAT_MIN]); */
 166
 167     if (verbose) g_warning("exec_cam_start:: fps = %d", cam_var->misc_info[0].framerate/*  - FRAMERATE_MIN */);
 168     if (dc1394_setup_capture(cam_var->camera[0].handle,
 169                              cam_var->camera[0].id,
 170                              cam_var->misc_info[0].iso_channel,
 171                              cam_var->misc_info[0].format,
 172                              cam_var->misc_info[0].mode,
 173                              cam_var->maxspeed,
 174
 175                              cam_var->misc_info[0].framerate,
 176
 177 /*                              FRAMERATE_7_5,   */
 178
 179 /* FRAMERATE_3_75, */
 180
 181                              &cam_var->capture[0])
 182         != DC1394_SUCCESS) {
 183         dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
 184         raw1394_destroy_handle(cam_var->handle);
 185         warning_gpiv(_("Unable to setup camera-\n\
 186 check line %d of %s to make sure\n\
 187 that the video mode,framerate and format are\n\
 188 supported by your camera"),
 189                     __LINE__,__FILE__);
 190         return;
 191     }
 192
 193
 194 /*
 195  * have the camera start sending us data
 196  */
 197     if (dc1394_start_iso_transmission(cam_var->handle, cam_var->capture[0].node)
 198         != DC1394_SUCCESS) {
 199         dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
 200         raw1394_destroy_handle(cam_var->handle);
 201         warning_gpiv(_("Unable to start camera iso transmission"));
 202         return;
 203     }
 204
 205 /*
 206  * let sending data for a while before grabbing and storing to stabilize
 207  * data transfer
 208  */
 209 /*     sleep(1); */
 210     usleep(1000);
 211
 212
 213 /*
 214  * set trigger mode and use triggering or just free run
 215  */
 216
 217     if (gpiv_par->console__trigger_cam) {
 218         if (verbose) g_warning("exec_cam_start:: trigger_cam");
 219 /*             if (dc1394_set_trigger_mode(cam_var->handle,  */
 220 /*                                         cam_var->capture[0].node,  */
 221 /*                                         TRIGGER_MODE_0) != DC1394_SUCCESS) */
 222 /*                 { */
 223 /*                     warning_gpiv(_("unable to set camera trigger mode")); */
 224 /*                 } */
 225 /*             exec_trigger_start(); */
 226
 227             rec_and_display(gpiv);
 228
 229         /*             exec_trigger_stop(); */
 230     } else {
 231         if (verbose) g_warning("exec_cam_start:: !trigger_cam");
 232             rec_and_display(gpiv);
 233     }
 234
 235
 236 /*     pthread_exit(NULL); */
 237
 238 /*
 239  * Stop data transmission
 240  */
 241         if (verbose) g_warning("exec_cam_start:: Stop data transmission and release camera");
 242     if (dc1394_stop_iso_transmission(cam_var->handle, cam_var->capture[0].node)
 243         != DC1394_SUCCESS
 244 /*         && dc1394_release_camera(cam_var->handle, &cam_var->capture[0])   */
 245 /*         != DC1394_SUCCESS  */
 246         ) {
 247         warning_gpiv(_("couldn't stop the camera?"));
 248     }
 249 /* in: exec_stop_cam    dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);     */
 250 /*in: exec_stop_cam:    raw1394_destroy_handle(cam_var->handle); */
 251
 252 }
 253
 254
 255 void
 256 exec_cam_stop (void
 257                )
 258 /*-----------------------------------------------------------------------------
 259  */
 260 {
 261     gint i;
 262
 263     cancel_process = TRUE;
 264     for (i = 0; i < cam_var->numCameras; i++) {
 265         if (dc1394_stop_iso_transmission(cam_var->handle, cam_var->capture[i].node)
 266             != DC1394_SUCCESS)
 267             {
 268                 warning_gpiv(_("couldn't stop the camera?"));
 269             }
 270
 271         pthread_exit(NULL);
 272         dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
 273     }
 274     if (cam_var->numCameras > 0) {
 275         raw1394_destroy_handle(cam_var->handle);
 276     }
 277 }
 278
 279
 280
 281 /*
 282  * Callback functions
 283  */
 284 void
 285 on_menu_camera_select (GtkWidget *widget,
 286                        gpointer data)
 287 /* ----------------------------------------------------------------------------
 288  */
 289 {
 290 }
 291
 292
 293
 294 void
 295 on_menu_format (GtkWidget *widget,
 296                 gpointer data)
 297 /* ----------------------------------------------------------------------------
 298  */
 299 {
 300     GpivConsole * gpiv = gtk_object_get_data(GTK_OBJECT(widget), "gpiv");
 301     gint mode = (int) data;
 302     gint format = 0;
 303     gint was_iso_on;
 304 /*         change_mode_and_format(format, FORMAT_VGA_NONCOMPRESSED); */
 305 /*   IsoFlowCheck(state); */
 306
 307        if (verbose) g_message("on_menu_format:: ");
 308     if (!dc1394_get_iso_status(cam_var->camera[0].handle, cam_var->camera[0].id,
 309                                &cam_var->misc_info[0].is_iso_on)) {
 310         g_warning("Cannot get ISO status");
 311     } else {
 312         if (cam_var->misc_info[0].is_iso_on > 0) {
 313             cancel_process = TRUE;
 314         }
 315     }
 316     was_iso_on = cam_var->misc_info[0].is_iso_on;
 317 /*        g_message("on_menu_format:: is_iso_on = %d", was_iso_on); */
 318
 319
 320     if (mode >= MODE_FORMAT0_MIN && mode <= MODE_FORMAT0_MAX) {
 321         format = FORMAT_VGA_NONCOMPRESSED;
 322
 323 /*         g_message("on_menu_format:: mode[%d] = %s",  */
 324 /*                   mode, format0_desc[mode - MODE_FORMAT0_MIN]); */
 325
 326 /*         g_message(":n_menu_format: format[%d] = %s", */
 327 /*                   format, */
 328 /*                   format_desc[format - FORMAT_MIN]); */
 329     } else if  (mode >= MODE_FORMAT1_MIN && mode <= MODE_FORMAT1_MAX) {
 330         format = FORMAT_SVGA_NONCOMPRESSED_1;
 331     } else if  (mode >= MODE_FORMAT2_MIN && mode <= MODE_FORMAT2_MAX) {
 332         format = FORMAT_SVGA_NONCOMPRESSED_2;
 333     } else if  (mode >= MODE_FORMAT6_MIN && mode <= MODE_FORMAT6_MAX) {
 334         format = FORMAT_STILL_IMAGE;
 335     } else if  (mode >= MODE_FORMAT7_MIN && mode <= MODE_FORMAT7_MAX) {
 336         format = FORMAT_SCALABLE_IMAGE_SIZE;
 337 /*     } else if  (mode >= COLOR_FORMAT7_MIN && mode <= COLOR_FORMAT7_MAX) { */
 338 /*         format = FORMAT_SCALABLE_IMAGE_SIZE; */
 339     } else {
 340         warning_gpiv(_("on_menu_format: non valid format"));
 341     }
 342
 343     if (!dc1394_set_video_format(cam_var->camera[0].handle,
 344                                  cam_var->camera[0].id,
 345                                  format)) {
 346         if (verbose) g_warning("on_menu_format:: Could not set video format");
 347     } else {
 348         cam_var->misc_info[0].format = format;
 349     }
 350
 351     if (!dc1394_set_video_mode(cam_var->camera[0].handle,
 352                                cam_var->camera[0].id,
 353                                mode)) {
 354         if (verbose) g_warning("on_menu_format:: Could not set video format");
 355     } else {
 356         cam_var->misc_info[0].mode = mode;
 357     }
 358
 359
 360
 361     if (was_iso_on > 0) {
 362         exec_cam_start(gpiv);
 363     }
 364
 365 /*   BuildFpsMenu(); */
 366
 367
 368 /*   UpdateTriggerFrame(); */
 369
 370 /*   IsoFlowResume(state); */
 371
 372
 373 /*     MODE_320x240_YUV422, */
 374 /*     MODE_640x480_YUV411, */
 375 /*     MODE_640x480_YUV422, */
 376 /*     MODE_640x480_RGB, */
 377 /*     MODE_640x480_MONO, */
 378 /*     MODE_640x480_MONO16 */
 379 }
 380
 381
 382
 383 void
 384 on_menu_fps (GtkWidget *widget,
 385              gpointer data)
 386 /* ----------------------------------------------------------------------------
 387  */
 388 {
 389     cam_var->misc_info[0].framerate = (int) data/*  - FRAMERATE_MIN */;
 390 /* cam_var->misc_info[0].framerat */
 391     if (verbose) g_warning("on_menu_fps:: fps = %d", cam_var->misc_info[0].framerate);
 392 }
 393
 394
 395 /*
 396  * BUGFIX: include in trigger callbacks?
 397  */
 398 void
 399 on_trigger_polarity_toggled            (GtkToggleButton *togglebutton,
 400                                         gpointer         user_data)
 401 {
 402 /* ----------------------------------------------------------------------------
 403  */
 404   if (!dc1394_set_trigger_polarity(cam_var->camera[0].handle,
 405                                    cam_var->camera[0].id,
 406                                    togglebutton->active)) {
 407       message_gpiv(_("Cannot set trigger polarity"));
 408   } else {
 409       cam_var->feature_set[0].feature[FEATURE_TRIGGER-FEATURE_MIN].
 410           trigger_polarity = (int) togglebutton->active;
 411   }
 412 }
 413
 414
 415
 416 void
 417 on_trigger_external_toggled            (GtkToggleButton *togglebutton,
 418                                         gpointer         user_data)
 419 {
 420 /* ----------------------------------------------------------------------------
 421  */
 422   if (!dc1394_feature_on_off(cam_var->camera[0].handle,
 423                              cam_var->camera[0].id,
 424                              FEATURE_TRIGGER,
 425                              togglebutton->active)) {
 426       message_gpiv(_("Cannot set external trigger source"));
 427   } else {
 428       cam_var->feature_set[0].feature[FEATURE_TRIGGER - FEATURE_MIN].is_on =
 429           togglebutton->active;
 430   }
 431 /*   UpdateTriggerFrame(); */
 432 }
 433
 434
 435
 436 void
 437 on_trigger_mode_activate (GtkWidget *widget,
 438                          gpointer user_data)
 439 /* ----------------------------------------------------------------------------
 440  */
 441 {
 442   if (!dc1394_set_trigger_mode(cam_var->camera[0].handle, cam_var->camera[0].id,
 443                                (int) user_data)) {
 444       message_gpiv(_("Cannot set trigger mode"));
 445   } else {
 446       cam_var->feature_set[0].feature[FEATURE_TRIGGER-FEATURE_MIN].
 447           trigger_mode = (int) user_data;
 448   }
 449
 450 /*   UpdateTriggerFrame(); */
 451 }
 452
 453
 454
 455 /* void */
 456 /* on_trigger_value_changed               (GtkAdjustment    *adj, */
 457 /*                                         gpointer         user_data) */
 458 /* { */
 459 /*   if (!dc1394_set_feature_value(cam_var->camera[0].handle, cam_var->camera[0].id, */
 460 /*                                 FEATURE_TRIGGER, adj->value)) */
 461 /*     message_gpiv(_("Cannot set external trigger count")); */
 462 /*   else */
 463 /*     cam_var->feature_set[0].feature[FEATURE_TRIGGER-FEATURE_MIN].value = */
 464 /*        adj->value; */
 465 /* } */
 466
 467
 468 void
 469 on_checkbutton_camera_trigger_enter (GtkWidget *widget,
 470                                      gpointer data)
 471 /* ----------------------------------------------------------------------------
 472  */
 473 {
 474     GpivConsole * gpiv = gtk_object_get_data(GTK_OBJECT(widget), "gpiv");
 475     gchar *msg = _("Enables triggering of the camera");
 476     gnome_appbar_set_status(GNOME_APPBAR(gpiv->appbar), msg);
 477 }
 478
 479
 480
 481 void
 482 on_checkbutton_camera_trigger (GtkWidget *widget,
 483                                gpointer data)
 484 /* ----------------------------------------------------------------------------
 485  */
 486 {
 487     if (GTK_TOGGLE_BUTTON(widget)->active) {
 488         gpiv_par->console__trigger_cam = TRUE;
 489     } else {
 490         gpiv_par->console__trigger_cam = FALSE;
 491     }
 492 }
 493
 494
 495
 496 void
 497 on_man_auto_menu (GtkWidget *widget,
 498                   gpointer data)
 499 /* ----------------------------------------------------------------------------
 500  */
 501 {
 502     GtkWidget *scale = gtk_object_get_data(GTK_OBJECT(widget), "scale");
 503     int feature = (int) data;
 504     enum VariableType {
 505         MAN,
 506         AUTO
 507     } var_type;
 508
 509     var_type = atoi(gtk_object_get_data(GTK_OBJECT(widget), "var_type"));
 510     if (!dc1394_auto_on_off(cam_var->camera[0].handle,
 511                             cam_var->camera[0].id,
 512                             feature, var_type)) {
 513         message_gpiv(_("on_man_auto_menu: Cannnot set auto / manual"));
 514     }
 515
 516     if (var_type == MAN) {
 517         gtk_widget_set_sensitive (GTK_WIDGET(scale), TRUE);
 518     } else if (var_type == AUTO) {
 519         gtk_widget_set_sensitive (GTK_WIDGET(scale), FALSE);
 520     }
 521
 522 }
 523
 524
 525
 526 void
 527 on_scale_changed (GtkAdjustment *adj,
 528                   gpointer user_data)
 529 /* ----------------------------------------------------------------------------
 530  */
 531 {
 532     switch((int)user_data) {
 533     case FEATURE_TEMPERATURE:
 534         if (!dc1394_set_temperature(cam_var->camera[0].handle,
 535                                     cam_var->camera[0].id,
 536                                     adj->value))
 537             message_gpiv(_("on_scale_changed: Cannot set temperature"));
 538         else
 539             cam_var->feature_set[0].feature[FEATURE_TEMPERATURE-FEATURE_MIN].
 540                 value = adj->value;
 541         break;
 542
 543     default:
 544 /*         g_message("on_scale_changed:: feature = %d value = %f",  */
 545 /*                   (gint) user_data, adj->value); */
 546         if (!dc1394_set_feature_value(cam_var->camera[0].handle,
 547                                       cam_var->camera[0].id,
 548                                       (gint) user_data,
 549                                       adj->value)) {
 550             message_gpiv(_("on_scale_changed: Cannot set feature"));
 551         } else {
 552             cam_var->feature_set[0].feature[(gint) user_data - FEATURE_MIN].
 553                 value = adj->value;
 554         }
 555         break;
 556     }
 557
 558 }
 559
 560
 561
 562 void
 563 on_button_dac_camstart_enter (GtkWidget *widget,
 564                               gpointer data
 565                               )
 566 /*-----------------------------------------------------------------------------
 567  */
 568 {
 569     GpivConsole * gpiv = gtk_object_get_data(GTK_OBJECT(widget), "gpiv");
 570     gchar *msg = _("Records PIV images");
 571     gnome_appbar_set_status(GNOME_APPBAR(gpiv->appbar), msg);
 572 }
 573
 574
 575
 576 void
 577 on_button_dac_camstart (GtkWidget * widget,
 578                         gpointer data
 579                         )
 580 /* ----------------------------------------------------------------------------
 581  * The actual calculation of particle image displacements
 582  */
 583 {
 584     GpivConsole * gpiv = gtk_object_get_data(GTK_OBJECT(widget), "gpiv");
 585
 586     cancel_process = FALSE;
 587 /*in exec_cam_start:     exec_trigger_start(); */
 588     exec_cam_start(gpiv);
 589
 590 }
 591
 592
 593
 594 void
 595 on_button_dac_camstop_enter (GtkWidget *widget,
 596                              gpointer data
 597                              )
 598 /*-----------------------------------------------------------------------------
 599  */
 600 {
 601     GpivConsole * gpiv = gtk_object_get_data(GTK_OBJECT(widget), "gpiv");
 602     gchar *msg = _("Stops recording PIV images");
 603     gnome_appbar_set_status(GNOME_APPBAR(gpiv->appbar), msg);
 604 }
 605
 606
 607
 608 void
 609 on_button_dac_camstop (GtkWidget * widget,
 610                        gpointer data
 611                        )
 612 /* ----------------------------------------------------------------------------
 613  * The actual calculation of particle image displacements
 614  */
 615 {
 616     cancel_process = TRUE;
 617 #ifdef ENABLE_TRIG
 618     exec_trigger_stop();
 619 #endif
 620     exec_cam_stop();
 621 }
 622
 623
 624 /*
 625  * Local functions
 626  */
 627
 628 static int
 629 open_dac_img(GpivCamVar *cam_var,
 630              unsigned char **frameA,
 631              unsigned char **frameB,
 632              Image * img,
 633              gboolean alloc_mem
 634              )
 635 /*-----------------------------------------------------------------------------
 636  * Opens an image obtained from the camera (Counterpart of open_img from file)
 637  */
 638 {
 639     gint i, j;
 640     gchar *month;
 641 /*
 642  * parameter initializing of image
 643  */
 644     gpiv_img_parameters_set(img->image->header, FALSE);
 645
 646     img->image->header->ncolumns = cam_var->capture[0].frame_width;
 647     img->image->header->nrows = cam_var->capture[0].frame_height;
 648     img->image->header->x_corr = gpiv_par->x_corr;
 649     img->image->header->ncolumns__set = TRUE;
 650     img->image->header->nrows__set = TRUE;
 651     img->image->header->x_corr__set = TRUE;
 652
 653     gl_image_par = gpiv_img_cp_parameters (img->image->header);
 654     if (verbose) g_message("open_dac_img:: 1 creation_date = %s",
 655               img->image->header->creation_date);
 656 /*
 657  * Apply time and date to creation_date (buffer) parameter
 658  */
 659     month = month_name(g_date_month(date));
 660     g_snprintf(img->image->header->creation_date,
 661                GPIV_MAX_CHARS,
 662                "%d %s %d %d:%d:%d",
 663                g_date_day(date),
 664                month,
 665                g_date_year(date),
 666                dac_time->tm_hour,
 667                dac_time->tm_min,
 668                dac_time->tm_sec);
 669     g_free(month);
 670
 671
 672 /*     if(alloc_mem) { */
 673     img->img1 = gpiv_alloc_img(img->image_par);
 674 /*     } */
 675
 676     for (i = 0; i < img->image->header->nrows ; i++) {
 677         for (j = 0; j < img->image->header->ncolumns; j++) {
 678 /*
 679  * format 640x480 = 1:1.3
 680  */
 681             img->img1[i][j/*  + i/3 */] = (guint16) frameA[i][j];
 682         }
 683     }
 684
 685
 686
 687     if (gpiv_par->x_corr) {
 688  /*        if(alloc_mem) { */
 689         img->img2 = gpiv_alloc_img(img->image_par);
 690 /*         } */
 691         for (i = 0; i < img->image->header->nrows ; i++) {
 692             for (j = 0; j < img->image->header->ncolumns; j++) {
 693 /*
 694  * format 640x480 = 1:1.3
 695  */
 696                 img->img2[i][j/*  + i/3 */] = (guint16) frameB[i][j];
 697             }
 698         }
 699     } else {
 700         img->img2 = img->img1;
 701     }
 702
 703
 704     img->exist_img = TRUE;
 705     img->saved_img = FALSE;
 706     return 0;
 707 }
 708
 709
 710 static void
 711 load_dac_buffer (GpivConsole *gpiv,
 712                  GpivCamVar *cam_var,
 713                  gboolean second_image,
 714                  char *fname,
 715                  int ibuf,
 716                  unsigned char **frameA,
 717                  unsigned char **frameB,
 718                  enum ClistPut clist_put
 719                  )
 720 /*-----------------------------------------------------------------------------
 721  * create display and its (popup) menu, load image, piv data and puts
 722  * buffername into clist
 723  */
 724 {
 725     gint return_val = 0;
 726     gchar *clist_buf_txt[MAX_BUFS][2], cl_int[4];
 727
 728
 729     display[ibuf] = create_display(fname, ibuf, gpiv);
 730     display_act = display[ibuf];
 731     gtk_widget_show(display_act->mwin);
 732
 733 /*     zoom_display(display_act, display_act->zoom_index); */
 734
 735
 736
 737     g_snprintf (display_act->file_uri_name, GPIV_MAX_CHARS, "%s", fname);
 738     if((return_val = open_dac_img (cam_var, frameA, frameB,
 739                                    display_act->img, FALSE))
 740        != 0) {
 741         gtk_object_destroy (GTK_OBJECT(display[ibuf]->mwin));
 742         if (ibuf > 0) {
 743             ibuf = nbufs - 1;;
 744             display_act = display[ibuf];
 745         } else {
 746             display_act = NULL;
 747         }
 748         nbufs--;
 749         return;
 750     }
 751
 752 /*
 753  * Pop-up menu after loading data
 754  */
 755     display_act->display_popupmenu = create_display_popupmenu (display_act);
 756     gtk_widget_show (display_act->display_popupmenu);
 757     gtk_signal_connect_object (GTK_OBJECT(display_act->mwin),
 758                                "button_press_event",
 759                                GTK_SIGNAL_FUNC (on_my_popup_handler),
 760                                GTK_OBJECT(display_act->display_popupmenu));
 761
 762
 763     zoom_display (display_act, display_act->zoom_index);
 764
 765 /*
 766  * Displaying
 767  */
 768     create_background (display_act);
 769     create_img (display_act);
 770     if (display_act->img->exist_img ) {
 771         show_img1 (display_act);
 772     } else {
 773         hide_img1 (display_act);
 774     }
 775
 776     if (gl_image_par->x_corr) {
 777         if (display_act->img->exist_img) {
 778             show_img2 (display_act);
 779         } else {
 780             hide_img2 (display_act);
 781         }
 782     }
 783
 784
 785 /*     display_act->img.img_mean = image_mean(display_act->img.img1, */
 786 /*                                            gpiv_par->img_width,  */
 787 /*                                            gpiv_par->img_height); */
 788
 789
 790     if (gpiv_par->display__intregs == 1) {
 791         if (verbose) g_message("load_dac_buffer:: create_all_intregs");
 792         create_all_intregs(display_act);
 793     }
 794
 795 /*
 796  * Add buffer to list
 797  */
 798     g_snprintf(cl_int, 4, "%d", ibuf);
 799     clist_buf_txt[ibuf][0] = (gchar *) cl_int;
 800     clist_buf_txt[ibuf][1] = fname;
 801     if (clist_put == PREPEND) {
 802         gtk_clist_prepend(GTK_CLIST(gpiv->clist_buf),
 803                           clist_buf_txt[ibuf]);
 804     } else if (clist_put == INSERT) {
 805         gtk_clist_insert(GTK_CLIST(gpiv->clist_buf), ibuf,
 806                          clist_buf_txt[ibuf]);
 807     } else if (clist_put == APPEND) {
 808         gtk_clist_append(GTK_CLIST(gpiv->clist_buf),
 809                          clist_buf_txt[ibuf]);
 810     } else {
 811         error_gpiv("non-existent CLIST enumerate");
 812     }
 813
 814    gtk_clist_set_row_data(GTK_CLIST(gpiv->clist_buf), ibuf,
 815                            display_act);
 816
 817
 818 /*
 819  * Copy general image parameters to the buffer parameters
 820  * and display in imgh tabulator
 821  */
 822 /*    gpiv_img_cp_parameters(gl_image_par, display_act->img.image_par); */
 823
 824    if (verbose) g_message ("load_dac_buffer:: ncolumns=%d nrows = %d",
 825               display_act->img->image->header->ncolumns, display_act->img->image->header->nrows);
 826     gtk_widget_set_size_request (display_act->canvas,
 827                                  (gint) (display_act->zoom_factor *
 828                                          display_act->img->image->header->ncolumns),
 829                                  (gint) (display_act->zoom_factor *
 830                                          display_act->img->image->header->nrows));
 831
 832 }
 833
 834
 835
 836 static void
 837 rec_and_display (GpivConsole *gpiv
 838 /*                 , ImgFrame *img_frame */
 839                  )
 840 /*-----------------------------------------------------------------------------
 841  */
 842 {
 843     gint ibuf = 0;
 844     ImgFrame img_frame[GPIV_NIMG_MAX];
 845
 846     gint return_val = 0;
 847     pthread_t thread_rec;
 848     pthread_attr_t attr;
 849
 850     gint mode, cycles, DURATION;
 851     pthread_attr_init(&attr);
 852     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 853
 854
 855 /*
 856  * Select which parameters and constants to be used; from RTAI trigger
 857  * system (if enabled, this may be used) or from camera. If trigger has not
 858  * been enabled only from camera
 859  */
 860 #ifdef ENABLE_TRIG
 861     if (gpiv_par->process_trig) {
 862         mode = gl_trig_par.ttime.mode;
 863         cycles = gl_trig_par.ttime.cycles;
 864         DURATION = GPIV_TIMER_MODE__DURATION;
 865     } else {
 866         mode = gl_cam_par->mode;
 867         cycles = gl_cam_par->cycles;
 868         DURATION = GPIV_CAM_MODE__DURATION;
 869     }
 870 #else /* ENABLE_TRIG */
 871     mode = gl_cam_par->mode;
 872     cycles = gl_cam_par->cycles;
 873     DURATION = GPIV_CAM_MODE__DURATION;
 874 #endif /* ENABLE_TRIG */
 875
 876 /*
 877  * Closing existing buffer windows and cleaning up Clist
 878  * BUGFIX: windows remain open
 879  */
 880     if (mode == DURATION) {
 881         for (ibuf = 0; ibuf < nbufs; ibuf++) {
 882             if (display[ibuf] != NULL) {
 883                 close_buffer(gpiv, display[ibuf]);
 884             }
 885         }
 886         gtk_clist_clear(GTK_CLIST(gpiv->clist_buf));
 887         nbufs = 0;
 888
 889 /*
 890  * allocating image mem
 891  */
 892         for (ibuf = 0; ibuf < cycles; ibuf++) {
 893             img_frame[ibuf].A =
 894                 gpiv_ucmatrix(cam_var->capture[0].frame_height,
 895                               cam_var->capture[0].frame_width);
 896             if (gpiv_par->x_corr) {
 897                 img_frame[ibuf].B = gpiv_ucmatrix(cam_var->capture[0].frame_height,
 898                                                   cam_var->capture[0].frame_width);
 899             }
 900         }
 901
 902 /*
 903  * recording
 904  */
 905
 906 #define THREADING
 907 /*
 908  * use threading
 909  */
 910 /*         if (verbose)  */
 911 /*             g_message("rec_and_display:: Creating thread_rec from %d", pthread_self ()); */
 912 #ifdef THREADING
 913         if ((return_val = pthread_create (&thread_rec,
 914                                           &attr,
 915                                           (void *) &thread_rec_frame_serie,
 916                                           (void *) &img_frame)) == TRUE) {
 917             pthread_exit(NULL);
 918             g_error("return code from pthread_create() is %d\n", return_val);
 919         }
 920         pthread_join(thread_rec, NULL);
 921         if (verbose) g_message ("rec_and_display:: waited on thread_rec. Done");
 922
 923 /*
 924  * no threading used
 925  */
 926 #else
 927         for (ibuf = 0; ibuf < cycles; ibuf++) {
 928             if (cancel_process) break;
 929             rec_frame(&img_frame[ibuf]);
 930
 931             progress_value = (gfloat) (ibuf +  1.0) /
 932                 (gfloat) cycles;
 933             g_snprintf(progress_string, GPIV_MAX_CHARS,
 934                        "recording image #%d", ibuf);
 935             while (g_main_iteration(FALSE));
 936             gtk_progress_set_value(gnome_appbar_get_progress
 937                                    (GNOME_APPBAR(gpiv->appbar)),
 938                                    progress_value * 100.0);
 939             gnome_appbar_push(GNOME_APPBAR(gpiv->appbar),
 940                               progress_string);
 941     }
 942
 943 #endif /* THREADING */
 944 #undef THREADING
 945 /*
 946  * displaying and freeing image mem
 947  */
 948         for (ibuf = 0; ibuf < cycles; ibuf++) {
 949             add_buffer(gpiv, gpiv_var->fn_last[0], ibuf, img_frame[ibuf].A,
 950                        img_frame[ibuf].B);
 951             gpiv_free_ucmatrix(img_frame[ibuf].A);
 952             if (gpiv_par->x_corr) {
 953                 gpiv_free_ucmatrix(img_frame[ibuf].B);
 954             }
 955         }
 956
 957 /*
 958  * timing is indefinite periodic
 959  * display only and continuously images in buffer 0
 960  */
 961     } else {
 962         ibuf = 0;
 963         gtk_clist_select_row(GTK_CLIST(gpiv->clist_buf), ibuf, 0);
 964         if (verbose) g_message("rec_and_display:: INDEFINITE");
 965
 966 /* BUGFIX: for Gtk2 */
 967 /*                 gtk_progress_bar_set_pulse_step (GNOME_APPBAR(gpiv->appbar), */
 968 /*                                                  0.1); */
 969
 970         img_frame[ibuf].A =
 971             gpiv_ucmatrix(cam_var->capture[0].frame_height,
 972                           cam_var->capture[0].frame_width);
 973         if (gpiv_par->x_corr) {
 974             img_frame[ibuf].B = gpiv_ucmatrix(cam_var->capture[0].frame_height,
 975                                               cam_var->capture[0].frame_width);
 976         }
 977
 978         while (!cancel_process) {
 979             rec_frame(&img_frame[ibuf]);
 980             while (g_main_iteration(FALSE));
 981             renew_buffer(gpiv, gpiv_var->fn_last[0], ibuf, img_frame[ibuf].A,
 982                          img_frame[ibuf].B);
 983 /* BUGFIX: for Gtk2 */
 984 /*                     gtk_progress_bar_pulse ((GNOME_APPBAR(gpiv->appbar)) */
 985
 986
 987         }
 988
 989         gpiv_free_ucmatrix(img_frame[ibuf].A);
 990         if (gpiv_par->x_corr) {
 991             gpiv_free_ucmatrix(img_frame[ibuf].B);
 992         }
 993
 994     }
 995
 996    pthread_attr_destroy(&attr);
 997 }
 998
 999
1000 static void
1001 thread_rec_frame(void *img_frame)
1002 /*-----------------------------------------------------------------------------
1003  */
1004 {
1005     ImgFrame *my_frame = NULL;
1006     unsigned char **frameA = my_frame->A;
1007     unsigned char **frameB = my_frame->B;
1008
1009     if (verbose) g_warning("thread_rec_frame:: 0");
1010     my_frame = (ImgFrame *) img_frame;
1011
1012
1013 /*     unsigned char **frameA = gpiv_ucmatrix(cam_var->capture[0].frame_height,  */
1014 /*                           cam_var->capture[0].frame_width); */
1015
1016
1017     if (verbose) g_message("thread_rec_frame:: 0.1");
1018 /*
1019  * capture one frame
1020  */
1021     if (dc1394_single_capture(cam_var->handle, &cam_var->capture[0])
1022         != DC1394_SUCCESS) {
1023         dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
1024         raw1394_destroy_handle(cam_var->handle);
1025         warning_gpiv(_("unable to capture a frame"));
1026 /*         return(); */
1027     } else {
1028         if (verbose) g_message("thread_rec_frame:: 1");
1029
1030
1031 /*
1032  * Copy buffer content to tmp buffer array
1033  * block data for thread
1034  */
1035
1036         pthread_mutex_lock(&mutex_rec);
1037         memcpy( frameA[0], (const char *) cam_var->capture[0].capture_buffer,
1038                 sizeof(char) * cam_var->capture[0].frame_width *
1039                 cam_var->capture[0].frame_height);
1040         pthread_mutex_unlock(&mutex_rec);
1041         if (verbose) g_message("thread_rec_frame:: 2");
1042     }
1043
1044 /*
1045  * Repeat if cross correlation; x_corr = TRUE
1046  */
1047     if (gpiv_par->x_corr) {
1048         if (dc1394_single_capture(cam_var->handle, &cam_var->capture[0])
1049             != DC1394_SUCCESS) {
1050             dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
1051             raw1394_destroy_handle(cam_var->handle);
1052             warning_gpiv(_("unable to capture a frame"));
1053 /*             return(); */
1054         } else {
1055
1056             pthread_mutex_lock(&mutex_rec);
1057             memcpy( frameB[0], (const char *) cam_var->capture[0].capture_buffer,
1058                     sizeof(char) * cam_var->capture[0].frame_width *
1059                     cam_var->capture[0].frame_height);
1060             pthread_mutex_unlock(&mutex_rec);
1061         }
1062     }
1063
1064
1065 /*     gpiv_free_ucmatrix(frameA); */
1066
1067     if (verbose) g_warning("thread_rec_frame:: 3/3");
1068     pthread_exit(0);
1069 }
1070
1071
1072
1073
1074 static void
1075 thread_rec_frame_serie(ImgFrame img_frame[GPIV_NIMG_MAX]
1076                        )
1077 /*-----------------------------------------------------------------------------
1078  * capture a series of images
1079  */
1080 {
1081     gint ibuf, cycles;
1082
1083 #ifdef ENABLE_TRIG
1084     cycles = gl_trig_par.ttime.cycles;
1085 #else /* ENABLE_TRIG */
1086     cycles = gl_cam_par->cycles;
1087 #endif /* ENABLE_TRIG */
1088
1089 /* g_message("thread_rec_frame_series:: 0 with id = %d", (int) pthread_self ()); */
1090     for (ibuf = 0; ibuf < cycles; ibuf++) {
1091         if (cancel_process) break;
1092 /* BUGFIX: thread_rec_frame_serie calls  rec_frame, NOT thread_ rec_frame; correct?
1093    rec_frame(&img_frame[ibuf]);
1094    }
1095 /* g_message("thread_rec_frame_series:: 1/1"); */
1096         pthread_exit(NULL);
1097     }
1098 }
1099
1100
1101 static void
1102 rec_frame(ImgFrame *img_frame
1103           )
1104 /*-----------------------------------------------------------------------------
1105 /*
1106  * capture a single image frame or frame pair
1107  */
1108 {
1109
1110 /* g_message("rec_frame:: 0"); */
1111
1112     if (dc1394_single_capture(cam_var->handle, &cam_var->capture[0])
1113         != DC1394_SUCCESS) {
1114         dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
1115         raw1394_destroy_handle(cam_var->handle);
1116         g_warning("unable to capture a frame");
1117         return;
1118     }
1119
1120 /*
1121  * Copy buffer content to tmp buffer array
1122  */
1123     memcpy( img_frame->A[0],
1124             (const char *) cam_var->capture[0].capture_buffer,
1125             sizeof(char) * cam_var->capture[0].frame_width *
1126             cam_var->capture[0].frame_height);
1127
1128     if (gpiv_par->x_corr) {
1129 /*
1130  * capture second frame
1131  */
1132         if (dc1394_single_capture(cam_var->handle, &cam_var->capture[0])
1133             != DC1394_SUCCESS) {
1134             dc1394_release_camera(cam_var->handle, &cam_var->capture[0]);
1135             raw1394_destroy_handle(cam_var->handle);
1136             g_warning("unable to capture a frame");
1137             return;
1138         }
1139
1140         memcpy( img_frame->B[0],
1141                 (const char *) cam_var->capture[0].capture_buffer,
1142                 sizeof(char) * cam_var->capture[0].frame_width *
1143                 cam_var->capture[0].frame_height);
1144     }
1145
1146 /* g_message("rec_frame:: 3/3"); */
1147 }
1148
1149
1150
1151 static void
1152 add_buffer(GpivConsole *gpiv,
1153            gchar *fname_base,
1154            gint ibuf,
1155            unsigned char **frameA,
1156            unsigned char **frameB
1157            )
1158 /*-----------------------------------------------------------------------------
1159  */
1160 {
1161     gchar cbuf[4], cdate[GPIV_MAX_CHARS], ctime[GPIV_MAX_CHARS];
1162 /*     GTimeVal *my_gtime = NULL; */
1163     time_t ltime_t;
1164 /*
1165  * Use numbers or timing to concanate after buffer names
1166  */
1167
1168
1169 /* BUGFIX GTimeVal might be used for more accurate timing */
1170 /*     my_gtime = g_malloc(sizeof(GTimeVal)); */
1171 /*     g_get_current_time(my_gtime); */
1172
1173     date = g_date_new ();
1174     g_date_set_time(date, time (NULL));
1175     ltime_t = time(&ltime_t);
1176     dac_time = localtime(&ltime_t);
1177     g_snprintf(ctime, sizeof(gint) * 3 + 2,
1178                "%d.%d.%d_",
1179                dac_time->tm_hour,
1180                dac_time->tm_min,
1181                dac_time->tm_sec);
1182
1183
1184     g_snprintf(cdate, sizeof(gint) * 3 + 2,
1185                "%d.%d.%d_",
1186                g_date_day(date),
1187                g_date_month(date),
1188                g_date_year(date));
1189
1190     g_snprintf(cbuf, 4, "%d", ibuf);
1191
1192     if (gpiv_var->fname_date
1193         && gpiv_var->fname_time) {
1194         fname_base = g_strdup(g_strconcat(gpiv_var->fn_last[0],
1195                                           (gchar *) cdate,
1196                                           (gchar *) ctime,
1197                                           (gchar *) cbuf,
1198                                           NULL));
1199     } else if (gpiv_var->fname_date) {
1200         fname_base = g_strdup(g_strconcat(gpiv_var->fn_last[0],
1201                                           (gchar *) cdate,
1202                                           (gchar *) cbuf,
1203                                           NULL));
1204     } else if (gpiv_var->fname_time) {
1205         fname_base = g_strdup(g_strconcat(gpiv_var->fn_last[0],
1206                                           (gchar *) ctime,
1207                                           (gchar *) cbuf,
1208                                           NULL));
1209     } else {
1210         fname_base = g_strdup(g_strconcat(gpiv_var->fn_last[0],
1211                                           (gchar *) cbuf,
1212                                           NULL));
1213     }
1214
1215     load_dac_buffer(gpiv, cam_var, FALSE, fname_base, ibuf, frameA, frameB,
1216                     INSERT);
1217     nbufs++;
1218
1219 /*     g_free(my_gtime);  */
1220     g_free(fname_base);
1221     g_date_free(date);
1222     return;
1223 }
1224
1225
1226
1227 static void
1228 renew_buffer(GpivConsole *gpiv,
1229              gchar *fname_base,
1230              gint ibuf,
1231              unsigned char **frameA,
1232              unsigned char **frameB
1233              )
1234 /*-----------------------------------------------------------------------------
1235  * updates image of buffer
1236  */
1237 {
1238 /*
1239  * Open buffer 0 if not exist
1240  */
1241
1242     if (display[ibuf] == NULL) {
1243         add_buffer(gpiv, fname_base, ibuf, frameA, frameB);
1244     } else {
1245         display_act = display[ibuf];
1246
1247         recreate_img(display_act, frameA, frameB);
1248         if (display_act->img->exist_img) {
1249             show_img1(display_act);
1250         } else {
1251             hide_img1(display_act);
1252         }
1253
1254         if (gl_image_par->x_corr) {
1255             if (display_act->img->exist_img) {
1256                 show_img2(display_act);
1257             } else {
1258                 hide_img2(display_act);
1259             }
1260         }
1261
1262     }
1263
1264
1265 }
1266
1267
1268
1269 static void
1270 recreate_img(Display * disp,
1271              unsigned char **frameA,
1272              unsigned char **frameB
1273              )
1274 /* ----------------------------------------------------------------------------
1275  * Re-creates image in gnome canvas; without memallocating of rgbbuf_img1 and
1276  * rgbbuf_img2
1277  * row stride; each row is a 4-byte buffer array
1278  */
1279 {
1280     guchar *pos1 = NULL;
1281 /*     guchar *pos2 = NULL; */
1282     gint i, j;
1283     GdkPixbuf *pixbuf1 = NULL;
1284 /*     GdkPixbuf *pixbuf2 = NULL; */
1285     guint16 fact = 1;
1286     gint depth = 8;
1287
1288     assert (disp != NULL);
1289     //assert (disp->img->img1 != NULL);
1290     assert (disp->img->rgbbuf_img1 != NULL);
1291     if (disp->img->image->header->x_corr) {
1292       //  assert (disp->img->img2 != NULL);
1293         assert (disp->img->rgbbuf_img2 != NULL);
1294     }
1295     assert (disp->img->exist_img);
1296
1297
1298     fact = fact << (disp->img->image->header->depth - depth);
1299     disp->img->rgb_img_width = disp->img->image->header->ncolumns * 3;
1300     while ((disp->img->rgb_img_width) % 4 != 0) {
1301         disp->img->rgb_img_width++;
1302     }
1303
1304     pixbuf1 = gdk_pixbuf_new_from_data(disp->img->rgbbuf_img1,
1305                                        GDK_COLORSPACE_RGB,
1306                                        FALSE,          /* gboolean has_alpha */
1307                                        disp->img->image->header->depth,
1308                                        disp->img->image->header->ncolumns,
1309                                        disp->img->image->header->nrows,
1310                                        disp->img->rgb_img_width, /* rowstride */
1311                                        NULL,
1312                                        NULL);
1313
1314
1315
1316     pos1 = disp->img->rgbbuf_img1;
1317    for (i = 0; i < disp->img->image->header->nrows; i++) {
1318         for (j = 0; j < disp->img->image->header->ncolumns; j++) {
1319             *pos1++ =  (guchar) (frameA[i][j] / fact);
1320             *pos1++ =  (guchar) (frameA[i][j] / fact);
1321             *pos1++ =  (guchar) (frameA[i][j] / fact);
1322         }
1323     }
1324
1325
1326     gnome_canvas_item_set(GNOME_CANVAS_ITEM (disp->img->gci_img1),
1327                           "pixbuf", pixbuf1,
1328                           NULL);
1329 /*     gnome_canvas_item_raise_to_top (GNOME_CANVAS_ITEM (disp->img->gci_img1)); */
1330 /*     gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (disp->img->gci_img1)); */
1331
1332 /* gtk_widget_pop_visual(); */
1333 /*   gtk_widget_pop_colormap(); */
1334
1335
1336     gdk_pixbuf_unref (pixbuf1);
1337
1338
1339
1340 /*     if(image->header->x_corr) { */
1341 /*         pos2 = NULL; */
1342
1343 /*         disp->img->rgbbuf_img2 = g_malloc(disp->img->rgb_img_width * 3 * */
1344 /*                                          gpiv_par->img_height); */
1345
1346 /*         pixbuf2 = gdk_pixbuf_new_from_data(disp->img->rgbbuf_img2, */
1347 /*                                            GDK_COLORSPACE_RGB, */
1348 /*                                            FALSE,  */
1349 /*                                            depth,  */
1350 /*                                            gpiv_par->img_width,  */
1351 /*                                            gpiv_par->img_height, */
1352 /*                                            disp->img->rgb_img_width,  */
1353 /*                                            NULL,  */
1354 /*                                            NULL); */
1355
1356 /*         if (disp->img->gci_img2 != NULL) { */
1357 /*             destroy_img(disp); */
1358 /*         } */
1359
1360 /*         disp->img->gci_img2 =  */
1361 /*             gnome_canvas_item_new( gnome_canvas_root( GNOME_CANVAS */
1362 /*                                                       (disp->canvas)), */
1363 /*                                    gnome_canvas_pixbuf_get_type (), */
1364 /*                                    "pixbuf", pixbuf2, */
1365 /*                                    NULL); */
1366
1367
1368 /*         pos2 = disp->img->rgbbuf_img2; */
1369 /*         for (i = 0; i < gpiv_par->img_height; i++) { */
1370 /*             for (j = 0; j < gpiv_par->img_width; j++) { */
1371 /*                 *pos2++ = (guchar) (frameB[i][j] / fact); */
1372 /*                 *pos2++ = (guchar) (frameB[i][j] / fact); */
1373 /*                 *pos2++ = (guchar) (frameB[i][j] / fact); */
1374 /*             } */
1375 /*         } */
1376
1377 /*         gdk_pixbuf_unref (pixbuf2); */
1378
1379 /*     } else { */
1380         disp->img->gci_img2 = disp->img->gci_img2;
1381 /*     } */
1382
1383 }
1384
1385
1386
1387 #endif /* ENABLE_CAM */