• 在Ubuntu上用sane api实现通用扫描功能

    最近由于工作需要，要写一套扫描相关的接口。

    在这里记录一下，实现还有有点复杂的。

    目录

    依赖

    主要功能

    初始化

    获取当前扫描仪列表

    打开扫描仪

     sane_open

    设置扫描选项

    sane_control_option

    扫描

    关闭设备

    结束使用

    参考资料

    依赖

    sudo apt install libsane-dev  sane-utils

    主要功能

    初始化

    我们在操作扫描仪之前需要初始化才能正常使用。

    初始化使用的是sane里的sane_init。

    1. void scanner_init()
    2. {
    3.   printf("[%s] Start\n", __FUNCTION__);
    4.   SANE_Int version_code = 0;
    5.   sane_init(&version_code, auth_callback);
    6.   printf("SANE version code: %d\n", version_code);
    7. }
    8.  
    9. static void
    10. auth_callback(SANE_String_Const resource,
    11.               SANE_Char *username, SANE_Char *password)
    12. {
    13. }

    初始化成功则version_code为SANE_STATUS_GOOD（0）。

    获取当前扫描仪列表

    核心是sane_get_devices函数。

    先通过sane_get_devices获取扫描仪列表，然后申请一个二维数组，将扫描仪列表放入二维数组中返回。

    1. const char **scanner_get_available_list()
    2. {
    3.   printf("[%s] Start\n", __FUNCTION__);
    4.   SANE_Status status;
    5.   SANE_Int num_devices = 0;
    6.   const SANE_Device **device_list;
    7.  
    8.   //获取扫描仪列表
    9.   status = sane_get_devices(&device_list, SANE_FALSE);
    10.   if (status != SANE_STATUS_GOOD)
    11.   {
    12.     printf("Error getting device list: %s\n", sane_strstatus(status));
    13.     return NULL;
    14.   }
    15.  
    16.   // 获取当前设备数量
    17.   while (device_list[num_devices])
    18.     num_devices++;
    19.  
    20.   // 如果设备列表为空，返回
    21.   if (num_devices == 0)
    22.   {
    23.     printf("No scanners found.\n");
    24.     sane_exit();
    25.     return NULL;
    26.   }
    27.  
    28.   // 分配内存
    29.   const char **scanner_list = malloc(sizeof(SANE_Device *) * (num_devices + 1));
    30.   if (!scanner_list)
    31.   {
    32.     printf("Failed to allocate memory.\n");
    33.     sane_exit();
    34.     return NULL;
    35.   }
    36.  
    37.   // 继续分配内存
    38.   for (int i = 0; i < num_devices; i++)
    39.   {
    40.     scanner_list[i] = strdup(device_list[i]->name);
    41.     if (!scanner_list[i])
    42.     {
    43.       printf("Failed to allocate memory.\n");
    44.       for (int j = 0; j < i; j++)
    45.       {
    46.         free(scanner_list[j]);
    47.       }
    48.       free(scanner_list);
    49.       sane_exit();
    50.       return NULL;
    51.     }
    52.   }
    53.   scanner_list[num_devices] = NULL;
    54.  
    55.   // 返回设备列表
    56.   return scanner_list;
    57. }

    我们再把获取到的设备列表循环打印一下。

    1.     const char **scanner_list = scanner_get_available_list();
    2.  
    3.     if (scanner_list != NULL)
    4.     {
    5.         for (int num_devices = 0; scanner_list[num_devices]; ++num_devices)
    6.         {
    7.             if (scanner_list[num_devices] != NULL) // 添加一个检查
    8.             {
    9.                 printf("Device %d: name=%s \n",
    10.                        num_devices, scanner_list[num_devices]);
    11.             }
    12.         }
    13.     }
    14.     else
    15.     {
    16.         return;
    17.     }

    打开扫描仪

     sane_open

    这里介绍一下sane_open，第一个参数是扫描仪的名称，第二个参数是一个空的句柄，打开后通过句柄进行后续操作。

    1. extern SANE_Status sane_open (SANE_String_Const devicename,
    2. 			      SANE_Handle * handle);

     函数的具体实现如下：

    1. static SANE_Handle sane_handle = NULL; // 扫描仪设备句柄，全局变量
    2.  
    3. int scanner_open_device(char *scanner_name)
    4. {
    5.   printf("[%s] Start\n", __FUNCTION__);
    6.   SANE_Status sane_status = 0;
    7.  
    8.   if (sane_status = sane_open(scanner_name, &sane_handle))
    9.   {
    10.     printf("sane_open status: %s\n", sane_strstatus(sane_status));
    11.   }
    12.   if (sane_status != SANE_STATUS_GOOD)
    13.     sane_handle = NULL;
    14.  
    15.   return sane_status;
    16. }

    这里的入参scanner_name是扫描仪列表的scanner_list，如果要打开第一个扫描仪的话是scanner_list[0]。

    如果函数的返回值不是SANE_STATUS_GOOD，表示打开失败了。

    设置扫描选项

    sane_control_option

    扫描的所有参数都是通过sane_control_option实现的，每个参数的功能详见备注。

    1. extern SANE_Status sane_control_option (SANE_Handle handle,  //sane_open的句柄
    2.                                         SANE_Int option,     //要设置选项的序号，2是颜色，3是分辨率
    3. 					                    SANE_Action action,  //操作的类型，给选项赋值或者获取当前值
    4.                                         void *value,         //value的实际值
    5. 					                    SANE_Int *info);     //没发现有什么用
    6.

     操作的类型一共有以下三种，我们这里只用到第二种。

    1. typedef enum
    2.   {
    3.     SANE_ACTION_GET_VALUE = 0,
    4.     SANE_ACTION_SET_VALUE,
    5.     SANE_ACTION_SET_AUTO
    6.   }
    7. SANE_Action;

    我这里设置了颜色，扫描的分辨率和纸张大小，还有很多可以设置的选项，可以自行探索。

    1. static SANE_Handle sane_handle = NULL; // 扫描仪设备句柄，全局变量
    2.  
    3. // 设置指定扫描仪颜色，通过传入参数val_color进行设置扫描设备的颜色
    4. int scanner_set_color(SANE_String val_color)
    5. {
    6.   printf("[%s] Start!\n", __FUNCTION__);
    7.   SANE_Status status;
    8.   status = sane_control_option(sane_handle, 2,
    9.                                SANE_ACTION_SET_VALUE, val_color, NULL);
    10.  
    11.   if (status != SANE_STATUS_GOOD)
    12.   {
    13.     printf("Option did not set, desc = %s\n", sane_strstatus(status));
    14.  
    15.     return status;
    16.   }
    17.  
    18.   printf("set color option success!\n");
    19.   return status;
    20. }
    21.  
    22.  
    23. // 设置指定扫描仪扫描的分辨率（清晰程度，分辨率越大越清晰）
    24. int scanner_set_resolutions(SANE_Int val_resolution)
    25. {
    26.   printf("[%s] Start!\n", __FUNCTION__);
    27.   SANE_Status status;
    28.  
    29.   status = sane_control_option(sane_handle, 3, SANE_ACTION_SET_VALUE, &val_resolution, NULL);
    30.   if (status != SANE_STATUS_GOOD)
    31.   {
    32.     printf("Option did not set, desc = %s\n", sane_strstatus(status));
    33.     return status;
    34.   }
    35.  
    36.   printf("set resolution option success!\n");
    37.   return status;
    38. }

    设置纸张大小有点复杂，因为纸张大小没有对应的option。因此曲线救国，通过设置扫描的纸张的长和宽来实现。长和宽的option序号分别是9和10。

    1. enum sizes_type
    2. {
    3.   A2 = 1,
    4.   A3,
    5.   A4,
    6.   A5,
    7.   A6
    8. };
    9.  
    10. static double g_saneSizeA4BrY = 297;
    11.  
    12. int scanner_set_size(SANE_String size)
    13. {
    14.   printf("[%s] Start!\n", __FUNCTION__);
    15.   SANE_Status status = SANE_STATUS_GOOD;
    16.   int type;
    17.  
    18.   if (!strcmp("A2", size))
    19.   {
    20.     type = A2;
    21.   }
    22.   else if (!strcmp("A3", size))
    23.   {
    24.     type = A3;
    25.   }
    26.   else if (!strcmp("A4", size))
    27.   {
    28.     type = A4;
    29.   }
    30.   else if (!strcmp("A5", size))
    31.   {
    32.     type = A5;
    33.   }
    34.   else if (!strcmp("A6", size))
    35.   {
    36.     type = A6;
    37.   }
    38.   else
    39.   {
    40.     type = 0;
    41.   }
    42.  
    43.   switch (type)
    44.   {
    45.   case A2:
    46.     status = kdk_scanner_set_size_real(sane_handle, 420, 594);
    47.     break;
    48.   case A3:
    49.     status = kdk_scanner_set_size_real(sane_handle, 297, 420);
    50.     break;
    51.   case A4:
    52.     status = kdk_scanner_set_size_real(sane_handle, 210, g_saneSizeA4BrY);
    53.     break;
    54.   case A5:
    55.     status = kdk_scanner_set_size_real(sane_handle, 148, 210);
    56.     break;
    57.   case A6:
    58.     status = kdk_scanner_set_size_real(sane_handle, 105, 144);
    59.     break;
    60.   default:
    61.     status = SANE_STATUS_UNSUPPORTED;
    62.   }
    63.  
    64.   return status;
    65. }
    66.  
    67. /**
    68.  * @brief scanner_set_size_real 统一设置扫描设备尺寸
    69.  *
    70.  * @param sane_handle 扫描句柄
    71.  *
    72.  * @param val_size_br_x 扫描设备右下角的x坐标
    73.  *
    74.  * @param val_size_br_y 扫描设备右下角的y坐标
    75.  *
    76.  * @return 返回扫描设备设置尺寸的情况
    77.  */
    78. SANE_Status scanner_set_size_real(SANE_Handle sane_handle, SANE_Int val_size_br_x,
    79.                                       SANE_Int val_size_br_y)
    80. {
    81.   printf("[%s] Start!\n", __FUNCTION__);
    82.   SANE_Status status = SANE_STATUS_GOOD;
    83.  
    84.   SANE_Word x = SANE_FIX(val_size_br_x);
    85.   SANE_Word y = SANE_FIX(val_size_br_y);
    86.  
    87.   SANE_Word zero = SANE_FIX(0.0);
    88.   status = sane_control_option(sane_handle, 7, SANE_ACTION_SET_VALUE, &zero, NULL);
    89.   if (status != SANE_STATUS_GOOD)
    90.   {
    91.     return status;
    92.   }
    93.  
    94.   status = sane_control_option(sane_handle, 8, SANE_ACTION_SET_VALUE, &zero, NULL);
    95.   if (status != SANE_STATUS_GOOD)
    96.   {
    97.     return status;
    98.   }
    99.  
    100.   status = sane_control_option(sane_handle, 9,
    101.                                SANE_ACTION_SET_VALUE, &x, NULL);
    102.  
    103.   if (status != SANE_STATUS_GOOD)
    104.   {
    105.     printf("Option x did not set, desc = %s\n", sane_strstatus(status));
    106.    
    107.     return status;
    108.   }
    109.  
    110.   status = sane_control_option(sane_handle, 10,
    111.                                SANE_ACTION_SET_VALUE, &y, NULL);
    112.  
    113.   if (status != SANE_STATUS_GOOD)
    114.   {
    115.     printf("Option y did not set, desc = %s\n", sane_strstatus(status));
    116.      
    117.     return status;
    118.   }
    119.  
    120.   return status;
    121. }

    和前面一样，如果函数的返回值不是SANE_STATUS_GOOD，表示失败了。

    扫描

    扫描我分成两类，分为单页单面扫描和多页双面扫描。

    单页和多页也是一种可以设置的扫描属性，单页和多页的主要是这个这个属性的区别，别的部分都差不多。

    1. //设置扫描是单页还是多页
    2. int scanner_set_page_type(SANE_Int type)
    3. {
    4.   printf("[%s] Start!\n", __FUNCTION__);
    5.   SANE_Status status;
    6.  
    7.   //对应的option序号为4
    8.   status = sane_control_option(sane_handle, 4,
    9.                                SANE_ACTION_SET_VALUE, &type, NULL);
    10.  
    11.   if (status != SANE_STATUS_GOOD)
    12.   {
    13.     printf("Option did not set, desc = %s\n", sane_strstatus(status));
    14.  
    15.     return status;
    16.   }
    17.  
    18.   printf("set page type option success!\n");
    19.   return status;
    20. }

    单页单面扫描，就是不管有多少页都只扫描第一页的第一面。

    1.   /**
    2.    * @brief 指定扫描仪进行扫描（统一按照多页，双面处理）
    3.    *
    4.    * @param fileName：保存扫描文件的文件名，比如传test的话，扫描后的文件会是test_1,test_2之类的形式
    5.    * 
    6.    * @param type:扫描类型 0：单面单面扫描，1：多页双面扫描
    7.    *
    8.    * @return 操作的返回值，0或者7为成功，其他为失败
    9.    */
    10. int scanner_start_scan(SANE_String_Const fileName, int type)
    11. {
    12.   printf("[%s] Start\n", __FUNCTION__);
    13.   SANE_Status sane_status = 0;
    14.  
    15.   switch (type)
    16.   {
    17.   case 0:
    18.     return do_scan_one(fileName);
    19.  
    20.   case 1:
    21.     return do_scan_all(fileName);
    22.  
    23.   default:
    24.     return do_scan_all(fileName);
    25.   }
    26. }
    27.

    这是扫描单页的接口

    1. // 单页扫描
    2. SANE_Status do_scan_one(const char *fileName)
    3. {
    4.   printf("[%s] Start\n", __FUNCTION__);
    5.  
    6.   del_old_pic();//扫描之前删掉上一次的内容
    7.  
    8.   SANE_Status status;
    9.   FILE *ofp = NULL;
    10.   char path[PATH_MAX];
    11.   char part_path[PATH_MAX];
    12.   buffer_size = (32 * 1024);
    13.   buffer = (SANE_Byte *)malloc(buffer_size);
    14.   int i = 1;
    15.  
    16.   // 设置打印机单页进纸张
    17.   status = kdk_scanner_set_page_type(1);
    18.   if (status != SANE_STATUS_GOOD)
    19.   {
    20.       printf("set page type fail:%s\n", sane_strstatus(status));
    21.       return status;
    22.   }
    23.  
    24.   do
    25.   {
    26.     // 设置保存路径
    27.     sprintf(path, "/tmp/%s-%d.pnm", fileName, i); // 格式化PNM文件路径
    28.     strcpy(part_path, path);
    29.     strcat(part_path, ".part");
    30.  
    31.     printf("picture name: %s\n", path);
    32.  
    33.     // 开始扫描
    34.     status = sane_start(sane_handle);
    35.     if (status != SANE_STATUS_GOOD)
    36.     {
    37.       break;
    38.     }
    39.  
    40.     if (NULL == (ofp = fopen(part_path, "w")))
    41.     {
    42.       status = SANE_STATUS_ACCESS_DENIED;
    43.       break;
    44.     }
    45.  
    46.     // 保存扫描数据
    47.     status = scan_it(ofp);
    48.  
    49.     switch (status)
    50.     {
    51.     case SANE_STATUS_GOOD:
    52.     case SANE_STATUS_EOF:
    53.     {
    54.       status = SANE_STATUS_GOOD;
    55.       if (!ofp || 0 != fclose(ofp))
    56.       {
    57.         status = SANE_STATUS_ACCESS_DENIED;
    58.         break;
    59.       }
    60.       else
    61.       {
    62.         ofp = NULL;
    63.         if (rename(part_path, path))
    64.         {
    65.           status = SANE_STATUS_ACCESS_DENIED;
    66.           break;
    67.         }
    68.       }
    69.     }
    70.     break;
    71.     default:
    72.       break;
    73.     }
    74.   } while (0);
    75.  
    76.  
    77.   if (ofp)
    78.   {
    79.     fclose(ofp);
    80.     ofp = NULL;
    81.   }
    82.   if (buffer)
    83.   {
    84.     free(buffer);
    85.     buffer = NULL;
    86.   }
    87.  
    88.   return status;
    89. }
    90.  
    91. // 删除上一次扫描的文件
    92. void del_old_pic()
    93. {
    94.   DIR *dir;
    95.   struct dirent *entry;
    96.   char path[] = "/tmp/";
    97.   char ext[] = ".pnm";
    98.  
    99.   dir = opendir(path);
    100.   if (dir == NULL)
    101.   {
    102.     perror("Unable to open directory");
    103.     exit(EXIT_FAILURE);
    104.   }
    105.  
    106.   while ((entry = readdir(dir)) != NULL)
    107.   {
    108.     // Check if the entry is a file and ends with .pnm
    109.     if (entry->d_type == DT_REG &&
    110.         strstr(entry->d_name, ext) != NULL &&
    111.         strcmp(entry->d_name + strlen(entry->d_name) - strlen(ext), ext) == 0)
    112.     {
    113.       char full_path[512];
    114.       sprintf(full_path, "%s%s", path, entry->d_name);
    115.  
    116.       if (remove(full_path) == 0)
    117.       {
    118.         printf("Deleted %s\n", full_path);
    119.       }
    120.       else
    121.       {
    122.         perror("Unable to delete file");
    123.       }
    124.     }
    125.   }
    126.  
    127.   closedir(dir);
    128. }
    129.  
    130. // sane 设置扫描方式
    131. int kdk_scanner_set_page_type(SANE_Int type)
    132. {
    133.   printf("[%s] Start!\n", __FUNCTION__);
    134.   SANE_Status status;
    135.   status = sane_control_option(sane_handle, 4,
    136.                                SANE_ACTION_SET_VALUE, &type, NULL);
    137.  
    138.   if (status != SANE_STATUS_GOOD)
    139.   {
    140.     printf("Option did not set, desc = %s\n", sane_strstatus(status));
    141.  
    142.     return status;
    143.   }
    144.  
    145.   printf("set page type option success!\n");
    146.   return status;
    147. }

    保存图片，这一部分细节很多，我也没仔细研究，直接用就行。

    1. static SANE_Status scan_it(FILE *ofp)
    2. {
    3.   int i, len, first_frame = 1, offset = 0, must_buffer = 0, hundred_percent;
    4.   SANE_Byte min = 0xff, max = 0;
    5.   SANE_Parameters parm;
    6.   SANE_Status status;
    7.   Image image = {0, 0, 0, 0, 0};
    8.   static const char *format_name[] = {"gray", "RGB", "red", "green", "blue"};
    9.   SANE_Word total_bytes = 0, expected_bytes;
    10.   SANE_Int hang_over = -1;
    11.  
    12.   do
    13.   {
    14.  
    15.     if (!first_frame)
    16.     {
    17.       status = sane_start(sane_handle);
    18.       if (status != SANE_STATUS_GOOD)
    19.       {
    20.         goto cleanup;
    21.       }
    22.     }
    23.  
    24.     status = sane_get_parameters(sane_handle, &parm);
    25.     if (status != SANE_STATUS_GOOD)
    26.     {
    27.       goto cleanup;
    28.     }
    29.  
    30.     if (first_frame)
    31.     {
    32.       switch (parm.format)
    33.       {
    34.       case SANE_FRAME_RED:
    35.       case SANE_FRAME_GREEN:
    36.       case SANE_FRAME_BLUE:
    37.         assert(parm.depth == 8);
    38.         must_buffer = 1;
    39.         offset = parm.format - SANE_FRAME_RED;
    40.         break;
    41.       case SANE_FRAME_RGB:
    42.         assert((parm.depth == 8) || (parm.depth == 16));
    43.       case SANE_FRAME_GRAY:
    44.         assert((parm.depth == 1) || (parm.depth == 8) || (parm.depth == 16));
    45.         if (parm.lines < 0)
    46.         {
    47.           must_buffer = 1;
    48.           offset = 0;
    49.         }
    50.         else
    51.         {
    52.           write_pnm_header(parm.format, parm.pixels_per_line, parm.lines, parm.depth, ofp);
    53.         }
    54.         break;
    55.       default:
    56.         break;
    57.       }
    58.  
    59.       if (must_buffer)
    60.       {
    61.         image.width = parm.bytes_per_line;
    62.         if (parm.lines >= 0)
    63.           image.height = parm.lines - STRIP_HEIGHT + 1;
    64.         else
    65.           image.height = 0;
    66.  
    67.         image.x = image.width - 1;
    68.         image.y = -1;
    69.         if (!advance(&image))
    70.         {
    71.           status = SANE_STATUS_NO_MEM;
    72.           goto cleanup;
    73.         }
    74.       }
    75.     }
    76.     else
    77.     {
    78.       assert(parm.format >= SANE_FRAME_RED && parm.format <= SANE_FRAME_BLUE);
    79.       offset = parm.format - SANE_FRAME_RED;
    80.       image.x = image.y = 0;
    81.     }
    82.  
    83.     hundred_percent = parm.bytes_per_line * parm.lines * ((parm.format == SANE_FRAME_RGB || parm.format == SANE_FRAME_GRAY) ? 1 : 3);
    84.  
    85.     // 这段是写图片数据
    86.     while (1)
    87.     {
    88.       double progr;
    89.       status = sane_read(sane_handle, buffer, buffer_size, &len);
    90.       total_bytes += (SANE_Word)len;
    91.       progr = ((total_bytes * 100.) / (double)hundred_percent);
    92.       if (progr > 100.)
    93.         progr = 100.;
    94.  
    95.       if (status != SANE_STATUS_GOOD)
    96.       {
    97.         if (status != SANE_STATUS_EOF)
    98.         {
    99.           return status;
    100.         }
    101.         break;
    102.       }
    103.  
    104.       if (must_buffer)
    105.       {
    106.         switch (parm.format)
    107.         {
    108.         case SANE_FRAME_RED:
    109.         case SANE_FRAME_GREEN:
    110.         case SANE_FRAME_BLUE:
    111.           for (i = 0; i < len; ++i)
    112.           {
    113.             image.data[offset + 3 * i] = buffer[i];
    114.             if (!advance(&image))
    115.             {
    116.               status = SANE_STATUS_NO_MEM;
    117.               goto cleanup;
    118.             }
    119.           }
    120.           offset += 3 * len;
    121.           break;
    122.         case SANE_FRAME_RGB:
    123.           for (i = 0; i < len; ++i)
    124.           {
    125.             image.data[offset + i] = buffer[i];
    126.             if (!advance(&image))
    127.             {
    128.               status = SANE_STATUS_NO_MEM;
    129.               goto cleanup;
    130.             }
    131.           }
    132.           offset += len;
    133.           break;
    134.         case SANE_FRAME_GRAY:
    135.           for (i = 0; i < len; ++i)
    136.           {
    137.             image.data[offset + i] = buffer[i];
    138.             if (!advance(&image))
    139.             {
    140.               status = SANE_STATUS_NO_MEM;
    141.               goto cleanup;
    142.             }
    143.           }
    144.           offset += len;
    145.           break;
    146.         default:
    147.           break;
    148.         }
    149.       }
    150.       else /* ! must_buffer */
    151.       {
    152.         if ((parm.depth != 16))
    153.           fwrite(buffer, 1, len, ofp);
    154.         else
    155.         {
    156. #if !defined(WORDS_BIGENDIAN)
    157.           int i, start = 0;
    158.           /* check if we have saved one byte from the last sane_read */
    159.           if (hang_over > -1)
    160.           {
    161.             if (len > 0)
    162.             {
    163.               fwrite(buffer, 1, 1, ofp);
    164.               buffer[0] = (SANE_Byte)hang_over;
    165.               hang_over = -1;
    166.               start = 1;
    167.             }
    168.           }
    169.           /* now do the byte-swapping */
    170.           for (i = start; i < (len - 1); i += 2)
    171.           {
    172.             unsigned char LSB;
    173.             LSB = buffer[i];
    174.             buffer[i] = buffer[i + 1];
    175.             buffer[i + 1] = LSB;
    176.           }
    177.           /* check if we have an odd number of bytes */
    178.           if (((len - start) % 2) != 0)
    179.           {
    180.             hang_over = buffer[len - 1];
    181.             len--;
    182.           }
    183. #endif
    184.           fwrite(buffer, 1, len, ofp);
    185.         }
    186.       }
    187.  
    188.       if (verbose && parm.depth == 8)
    189.       {
    190.         for (i = 0; i < len; ++i)
    191.           if (buffer[i] >= max)
    192.             max = buffer[i];
    193.           else if (buffer[i] < min)
    194.             min = buffer[i];
    195.       }
    196.     }
    197.     first_frame = 0;
    198.   } while (!parm.last_frame);
    199.  
    200.   if (must_buffer)
    201.   {
    202.     image.height = image.y;
    203.     write_pnm_header(parm.format, parm.pixels_per_line, image.height, parm.depth, ofp);
    204.  
    205. #if !defined(WORDS_BIGENDIAN)
    206.     if (parm.depth == 16)
    207.     {
    208.       int i;
    209.       for (i = 0; i < image.height * image.width; i += 2)
    210.       {
    211.         unsigned char LSB;
    212.         LSB = image.data[i];
    213.         image.data[i] = image.data[i + 1];
    214.         image.data[i + 1] = LSB;
    215.       }
    216.     }
    217. #endif
    218.     fwrite(image.data, 1, image.height * image.width, ofp);
    219.   }
    220.  
    221.   fflush(ofp);
    222.  
    223. cleanup:
    224.   if (image.data)
    225.     free(image.data);
    226.  
    227.   return status;
    228. }
    229.  
    230. void write_pnm_header(SANE_Frame format, int width, int height, int depth, FILE *ofp)
    231. {
    232.   printf("[%s] Start\n", __FUNCTION__);
    233.   switch (format)
    234.   {
    235.   case SANE_FRAME_RED:
    236.   case SANE_FRAME_GREEN:
    237.   case SANE_FRAME_BLUE:
    238.   case SANE_FRAME_RGB:
    239.     fprintf(ofp, "P6\n# SANE data follows\n%d %d\n%d\n", width, height, (depth <= 8) ? 255 : 65535);
    240.     break;
    241.   default:
    242.     if (depth == 1)
    243.       fprintf(ofp, "P4\n# SANE data follows\n%d %d\n", width, height);
    244.     else
    245.       fprintf(ofp, "P5\n# SANE data follows\n%d %d\n%d\n", width, height, (depth <= 8) ? 255 : 65535);
    246.     break;
    247.   }
    248. }
    249.  
    250. static void *
    251. advance(Image *image)
    252. {
    253.   if (++image->x >= image->width)
    254.   {
    255.     image->x = 0;
    256.     if (++image->y >= image->height || !image->data)
    257.     {
    258.       size_t old_size = 0, new_size;
    259.  
    260.       if (image->data)
    261.         old_size = image->height * image->width;
    262.  
    263.       image->height += STRIP_HEIGHT;
    264.       new_size = image->height * image->width;
    265.  
    266.       if (image->data)
    267.         image->data = realloc(image->data, new_size);
    268.       else
    269.         image->data = malloc(new_size);
    270.       if (image->data)
    271.         memset(image->data + old_size, 0, new_size - old_size);
    272.     }
    273.   }
    274.   if (!image->data)
    275.     fprintf(stderr, "can't allocate image buffer (%dx%d)\n",
    276.             image->width, image->height);
    277.   return image->data;
    278. }

    双页扫描，用do_scan_all替换do_scan_one，其他的函数都一样。

    1. // 双面扫描全部文件+保存为PNM图像格式
    2. SANE_Status do_scan_all(const char *fileName)
    3. {
    4.   printf("[%s] Start\n", __FUNCTION__);
    5.  
    6.   SANE_Status status;           // 返回状态
    7.   FILE *ofp = NULL;             // 输出文件指针
    8.   char path[PATH_MAX];          // PNM文件路径
    9.   char part_path[PATH_MAX];     // 临时PNN文件路径
    10.   buffer_size = (32 * 1024);    // 缓冲区大小
    11.   buffer = malloc(buffer_size); // 动态分配缓冲区
    12.   int i = 1;
    13.  
    14.   del_old_pic();
    15.  
    16.   //设置打印机多页进纸张
    17.   status = kdk_scanner_set_page_type(0);
    18.   if (status != SANE_STATUS_GOOD)
    19.   {
    20.       printf("set page type fail:%s\n", sane_strstatus(status));
    21.       return status;
    22.   }
    23.  
    24.   do
    25.   {
    26.     sprintf(path, "/tmp/%s-%d.pnm", fileName, i); // 格式化PNM文件路径
    27.     strcpy(part_path, path);                      // 复制PNM文件路径到临时文件路径
    28.     strcat(part_path, ".part");                   // 在临时文件路径后添加扩展名".part"
    29.  
    30.     // 启动扫描过程
    31.     status = sane_start(sane_handle);
    32.     if (status != SANE_STATUS_GOOD)
    33.     {
    34.       break;
    35.     }
    36.  
    37.     // 创建临时文件
    38.     if (NULL == (ofp = fopen(part_path, "w")))
    39.     {
    40.       status = SANE_STATUS_ACCESS_DENIED;
    41.       break;
    42.     }
    43.  
    44.     // 进行扫描，并将结果写入到临时文件中
    45.     status = scan_it(ofp);
    46.  
    47.     switch (status)
    48.     {
    49.     case SANE_STATUS_GOOD:
    50.     case SANE_STATUS_EOF:
    51.     {
    52.       // 扫描成功或结束
    53.       status = SANE_STATUS_GOOD;
    54.  
    55.       // 关闭临时文件，并检查是否成功关闭
    56.       if (!ofp || 0 != fclose(ofp))
    57.       {
    58.         status = SANE_STATUS_ACCESS_DENIED;
    59.         break;
    60.       }
    61.       else
    62.       {
    63.         ofp = NULL; // 将文件指针设置为NULL，避免重复关闭
    64.         // 将临时文件重命名为正式的PNM文件
    65.         if (rename(part_path, path))
    66.         {
    67.           status = SANE_STATUS_ACCESS_DENIED;
    68.           break;
    69.         }
    70.       }
    71.     }
    72.     break;
    73.     default:
    74.       break;
    75.     }
    76.     i++;
    77.   } while (status == SANE_STATUS_GOOD);
    78.  
    79.   // 如果出现错误，则取消扫描进程
    80.   if (SANE_STATUS_GOOD != status)
    81.   {
    82.     sane_cancel(sane_handle);
    83.   }
    84.  
    85.   // 关闭输出文件
    86.   if (ofp)
    87.   {
    88.     fclose(ofp);
    89.     ofp = NULL;
    90.   }
    91.  
    92.   // 释放缓冲区内存
    93.   if (buffer)
    94.   {
    95.     free(buffer);
    96.     buffer = NULL;
    97.   }
    98.  
    99.   if ((status == SANE_STATUS_NO_DOCS) && (i > 1))
    100.     status = SANE_STATUS_GOOD;
    101.  
    102.   return status; // 返回状态
    103. }

    扫描完成会会在tmp下生成扫描文件。

    关闭设备

    1. void scanner_close_device()
    2. {
    3.   printf("[%s] Start\n", __FUNCTION__);
    4.   if (sane_handle != NULL)
    5.   {
    6.     sane_close(sane_handle);
    7.   }
    8.   sane_handle = NULL;
    9. }

    结束使用

    1. void scanner_exit()
    2. {
    3.   printf("[%s] Start\n", __FUNCTION__);
    4.   sane_exit();
    5. }

    参考资料

    Linux下通用扫描仪API——SANE（ Scanner Access Now Easy）_linux sane-CSDN博客

  • 相关阅读:
    前端监控日志产品
    Go微服务框架go-kratos实战05：分布式链路追踪 OpenTelemetry 使用
    Angular8升级到Angular11
    大模型从入门到应用——LangChain：代理（Agents）-[工具包（Toolkit）]
    如何在Ubuntu系统部署RabbitMQ服务器并公网访问【内网穿透】
    Python学习笔记之进程池pool
    Linux 关闭对应端口号进程
    算法---二进制字符串重新安排顺序需要的时间(Kotlin)
    linux screen会话管理 断开连接恢复会话
    Pr：湍流置换
  • 原文地址：https://blog.csdn.net/weixin_48885322/article/details/134463289