ZBar源码分析（三）

2021SC@SDUSC

目录

一、zbar_processor_create函数分析

二、zbar_processor_destroy函数分析

三、zbar_processor_init函数分析

四、zbar_processor_request_size函数分析

1.zbar_processor_request_size函数分析

2.zbar_processor_request_interface函数分析

3.zbar_processor_request_iomode函数分析

---

一、zbar_processor_create函数分析

zbar_processor_t *zbar_processor_create (int threaded)

该函数为构造器函数，函数需要传入线程参数

zbar_processor_t *proc = calloc(1, sizeof(zbar_processor_t));
    if(!proc)
        return(NULL);
    err_init(&proc->err, ZBAR_MOD_PROCESSOR);

    proc->scanner = zbar_image_scanner_create();
    if(!proc->scanner) {
        free(proc);
        return(NULL);
    }

    proc->threaded = !_zbar_mutex_init(&proc->mutex) && threaded;
    _zbar_processor_init(proc);
    return(proc);

该函数的目的在于：如果设置了线程并且线程可用，处理器将在适当的地方生成线程，以避免阻塞并提高响应能力

typedef struct zbar_processor_s zbar_processor_t;

该函数返回一个zbar_processor_t对象，可以在zbar.h文件中找到其定义

struct zbar_processor_s {
    errinfo_t err;                      /* error reporting */
    const void *userdata;               /* application data */

    zbar_video_t *video;                /* input video device abstraction */
    zbar_window_t *window;              /* output window abstraction */
    zbar_image_scanner_t *scanner;      /* barcode scanner */

    zbar_image_data_handler_t *handler; /* application data handler */

    unsigned req_width, req_height;     /* application requested video size */
    int req_intf, req_iomode;           /* application requested interface */
    uint32_t force_input;               /* force input format (debug) */
    uint32_t force_output;              /* force format conversion (debug) */

    int input;                          /* user input status */

    /* state flags */
    int threaded;
    int visible;                        /* output window mapped to display */
    int streaming;                      /* video enabled */
    int dumping;                        /* debug image dump */

    void *display;                      /* X display connection */
    unsigned long xwin;                 /* toplevel window */

    zbar_thread_t input_thread;         /* video input handler */
    zbar_thread_t video_thread;         /* window event handler */

    const zbar_symbol_set_t *syms;      /* previous decode results */

    zbar_mutex_t mutex;                 /* shared data mutex */

    /* API serialization lock */
    int lock_level;
    zbar_thread_id_t lock_owner;
    proc_waiter_t *wait_head, *wait_tail, *wait_next;
    proc_waiter_t *free_waiter;

    processor_state_t *state;
};

zbar_processor_s的具体属性可以在processor.h文件中找到，属性已经在之前的博客中解析过

二、zbar_processor_destroy函数分析

void zbar_processor_destroy (zbar_processor_t *proc)

该函数为析构函数，需要传入zbar_processor_t对象

zbar_processor_init(proc, NULL, 0);

    if(proc->syms) {
        zbar_symbol_set_ref(proc->syms, -1);
        proc->syms = NULL;
    }
    if(proc->scanner) {
        zbar_image_scanner_destroy(proc->scanner);
        proc->scanner = NULL;
    }

    _zbar_mutex_destroy(&proc->mutex);
    _zbar_processor_cleanup(proc);

    assert(!proc->wait_head);
    assert(!proc->wait_tail);
    assert(!proc->wait_next);

    proc_waiter_t *w, *next;
    for(w = proc->free_waiter; w; w = next) {
        next = w->next;
        _zbar_event_destroy(&w->notify);
        free(w);
    }

    err_cleanup(&proc->err);
    free(proc);

该函数的目的在于：清理与处理器关联的所有资源

三、zbar_processor_init函数分析

int zbar_processor_init (zbar_processor_t *proc,
                         const char *dev,
                         int enable_display)
{
	return 0;
	
	//if(proc->video)
 //       zbar_processor_set_active(proc, 0);

 //   if(proc->window && !proc->input_thread.started)
 //       _zbar_processor_close(proc);

 //   _zbar_mutex_lock(&proc->mutex);
 //   _zbar_thread_stop(&proc->input_thread, &proc->mutex);
 //   _zbar_thread_stop(&proc->video_thread, &proc->mutex);

 //   _zbar_processor_lock(proc);
 //   _zbar_mutex_unlock(&proc->mutex);

 //   if(proc->window) {
 //       zbar_window_destroy(proc->window);
 //       proc->window = NULL;
 //   }

 //   int rc = 0;
 //   if(proc->video) {
 //       zbar_video_destroy(proc->video);
 //       proc->video = NULL;
 //   }

 //   if(!dev && !enable_display)
 //       /* nothing to do */
 //       goto done;

 //   if(enable_display) {
 //       proc->window = zbar_window_create();
 //       if(!proc->window) {
 //           rc = err_capture(proc, SEV_FATAL, ZBAR_ERR_NOMEM,
 //                            __func__, "allocating window resources");
 //           goto done;
 //       }
 //   }

 //   if(dev) {
 //       proc->video = zbar_video_create();
 //       if(!proc->video) {
 //           rc = err_capture(proc, SEV_FATAL, ZBAR_ERR_NOMEM,
 //                            __func__, "allocating video resources");
 //           goto done;
 //       }
 //       if(proc->req_width || proc->req_height)
 //           zbar_video_request_size(proc->video,
 //                                    proc->req_width, proc->req_height);
 //       if(proc->req_intf)
 //           zbar_video_request_interface(proc->video, proc->req_intf);
 //       if((proc->req_iomode &&
 //           zbar_video_request_iomode(proc->video, proc->req_iomode)) ||
 //          zbar_video_open(proc->video, dev)) {
 //           rc = err_copy(proc, proc->video);
 //           goto done;
 //       }
 //   }

 //   /* spawn blocking video thread */
 //   int video_threaded = (proc->threaded && proc->video &&
 //                         zbar_video_get_fd(proc->video) < 0);
 //   if(video_threaded &&
 //      _zbar_thread_start(&proc->video_thread, proc_video_thread, proc,
 //                         &proc->mutex)) {
 //       rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_SYSTEM, __func__,
 //                        "spawning video thread");
 //       goto done;
 //   }

 //   /* spawn input monitor thread */
 //   int input_threaded = (proc->threaded &&
 //                         (proc->window ||
 //                          (proc->video && !video_threaded)));
 //   if(input_threaded &&
 //      _zbar_thread_start(&proc->input_thread, proc_input_thread, proc,
 //                         &proc->mutex)) {
 //       rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_SYSTEM, __func__,
 //                        "spawning input thread");
 //       goto done;
 //   }

 //   if(proc->window && !input_threaded &&
 //      (rc = proc_open(proc)))
 //       goto done;

 //   else if(proc->video) {
 //       int retry = -1;
 //       if(proc->window) {
 //           retry = zbar_negotiate_format(proc->video, proc->window);
 //           if(retry)
 //               fprintf(stderr,
 //                       "WARNING: no compatible input to output format\n"
 //                       "...trying again with output disabled\n");
 //       }
 //       if(retry)
 //           retry = zbar_negotiate_format(proc->video, NULL);

 //       if(retry) {
 //           zprintf(1, "ERROR: no compatible %s format\n",
 //                   (proc->video) ? "video input" : "window output");
 //           rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_UNSUPPORTED,
 //                            __func__, "no compatible image format");
 //       }
 //   }

 //done:
 //   _zbar_mutex_lock(&proc->mutex);
 //   proc_leave(proc);
 //   return(rc);
}

该函数的目的在于：对处理器进行（重新）初始化，打开视频输入设备 和/或 准备显示输出，但是不知道为什么函数内容都被注释掉了，不是很懂

四、zbar_processor_request_size函数分析

1.zbar_processor_request_size函数分析

int zbar_processor_request_size (zbar_processor_t *proc,
                                 unsigned width,
                                 unsigned height)
{
    proc_enter(proc);
    proc->req_width = width;
    proc->req_height = height;
    proc_leave(proc);
    return(0);
}

该函数的作用在于：从设备请求视频图像的首选大小

但是驱动程序可能会调整或完全忽略该请求

2.zbar_processor_request_interface函数分析

int zbar_processor_request_interface (zbar_processor_t *proc,
                                      int ver)
{
    proc_enter(proc);
    proc->req_intf = ver;
    proc_leave(proc);
    return(0);
}

该函数目的在于：请求首选视频驱动程序接口版本用于debug或测试

3.zbar_processor_request_iomode函数分析

int zbar_processor_request_iomode (zbar_processor_t *proc,
                                   int iomode)
{
    proc_enter(proc);
    proc->req_iomode = iomode;
    proc_leave(proc);
    return(0);
}

该函数目的在于：为请求首选视频I/O模式用于debug或测试

如果驱动程序不支持指定的模式，则会出现错误

I/O模式包括：

        0=自动检测

        1=使用read（）强制I/O

        2=使用mmap（）强制内存映射I/O

        3=强制用户PTR I/O（仅限v4l2）