python通达信选股接口-mjpgstreamer实现细节分析_ 股票程序化软件自动交易接口

mjpg-streamer实现细节分析

输入初始化input_init

input_init->init_videoIn这段代码是init_videoIn函数的实现。该函数用于初始化视频输入设备。函数接收多个参数，包括指向vdIn结构体的指针vd、设备名称device、宽度width、高度height、帧率fps、格式format、抓取方法grabmethod、全局上下文指针pglobal和IDid。函数的主要步骤如下：检查vd和device是否为NULL，如果是则返回-检查width和height是否为0，如果是则返回-检查grabmethod的值是否在0和1之间，如果不是，则将其设置为分配内存并初始化vd结构体中的指针成员。使用calloc函数分配内存并将设备名称拷贝到vd->videodevice中。设置vd结构体的其他成员变量，如toggleAvi、getPict、signalquit、width、height、fps、formatIn和grabmethod。调用init_v4l2函数初始化V4L2设备。枚举支持的格式并存储到全局上下文的in_formats数组中。如果当前格式与指定的format匹配，则将其索引存储到currentFormat中。枚举当前格式下支持的分辨率，并存储到相应的数据结构中。分配临时缓冲区和帧缓冲区，根据指定的格式和分辨率确定缓冲区的大小。返回0表示初始化成功。如果在初始化过程中发生错误，将执行错误处理步骤，释放已分配的内存并关闭视频设备，然后返回-1表示初始化失败。

int init_videoIn(struct vdIn *vd, char *device, int width,
                 int height, int fps, int format, int grabmethod, globals *pglobal, int id)
{
    if(vd == NULL || device == NULL) // 如果vd或device为空，则返回-1
        return -1;
    if(width == 0 || height == 0) // 如果width或height为0，则返回-1
        return -1;
    if(grabmethod < 0 || grabmethod > 1) // 如果grabmethod小于0或大于1，则将其设置为1
        grabmethod = 1;     //默认使用mmap;
    vd->videodevice = NULL; // 初始化vd的videodevice、status、pictName为NULL
    vd->status = NULL;
    vd->pictName = NULL;
    vd->videodevice = (char *) calloc(1, 16 * sizeof(char)); // 为vd的videodevice、status、pictName分配内存
    vd->status = (char *) calloc(1, 100 * sizeof(char));
    vd->pictName = (char *) calloc(1, 80 * sizeof(char));
    snprintf(vd->videodevice, 12, "%s", device); // 将device的值复制到vd的videodevice中
    vd->toggleAvi = 0; // 初始化vd的toggleAvi、getPict、signalquit为0、0、1
    vd->getPict = 0;
    vd->signalquit = 1;
    vd->width = width; // 初始化vd的width、height、fps、formatIn、grabmethod为传入的参数
    vd->height = height;
    vd->fps = fps;
    vd->formatIn = format;
    vd->grabmethod = grabmethod;
    if(init_v4l2(vd) < 0) { // 如果init_v4l2返回小于0的值，则输出错误信息并跳转到error标签
        fprintf(stderr, " Init v4L2 failed !! exit fatal 
");
        goto error;;
    }


    // 枚举格式
    int currentWidth, currentHeight = 0;
    struct v4l2_format currentFormat;
    currentFormat.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if(xioctl(vd->fd, VIDIOC_G_FMT, ¤tFormat) == 0) {
        currentWidth = currentFormat.fmt.pix.width;
        currentHeight = currentFormat.fmt.pix.height;
        DBG("Current size: %dx%d
", currentWidth, currentHeight);
    }

    pglobal->in[id].in_formats = NULL;
    for(pglobal->in[id].formatCount = 0; 1; pglobal->in[id].formatCount++) {
        struct v4l2_fmtdesc fmtdesc;
        fmtdesc.index = pglobal->in[id].formatCount;
        fmtdesc.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if(xioctl(vd->fd, VIDIOC_ENUM_FMT, &fmtdesc) < 0) {
            break;
        }

        if (pglobal->in[id].in_formats == NULL) {
            pglobal->in[id].in_formats = (input_format*)calloc(1, sizeof(input_format));
        } else {
            pglobal->in[id].in_formats = (input_format*)realloc(pglobal->in[id].in_formats, (pglobal->in[id].formatCount + 1) * sizeof(input_format));
        }

        if (pglobal->in[id].in_formats == NULL) {
            DBG("Calloc/realloc failed: %s
", strerror(errno));
            return -1;
        }


        // 将fmtdesc复制到pglobal->in[id].in_formats[pglobal->in[id].formatCount]中
        memcpy(&pglobal->in[id].in_formats[pglobal->in[id].formatCount], &fmtdesc, sizeof(input_format));

        // 如果fmtdesc.pixelformat等于format，则将pglobal->in[id].currentFormat设置为pglobal->in[id].formatCount
        if(fmtdesc.pixelformat == format)
            pglobal->in[id].currentFormat = pglobal->in[id].formatCount;

        DBG("Supported format: %s
", fmtdesc.description);

        // 枚举分辨率
        struct v4l2_frmsizeenum fsenum;
        fsenum.index = pglobal->in[id].formatCount;
        fsenum.pixel_format = fmtdesc.pixelformat;
        int j = 0;
        pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions = NULL;
        pglobal->in[id].in_formats[pglobal->in[id].formatCount].resolutionCount = 0;
        pglobal->in[id].in_formats[pglobal->in[id].formatCount].currentResolution = -1;
        while(1) {
            fsenum.index = j;
            j++;
            if(xioctl(vd->fd, VIDIOC_ENUM_FRAMESIZES, &fsenum) == 0) {
                pglobal->in[id].in_formats[pglobal->in[id].formatCount].resolutionCount++;

                // 为pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions分配内存
                if (pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions == NULL) {
                    pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions =
                        (input_resolution*)calloc(1, sizeof(input_resolution));
                } else {
                    pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions =
                        (input_resolution*)realloc(pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions, j * sizeof(input_resolution));
                }

                // 如果分配内存失败，则输出错误信息并返回-1
                if (pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions == NULL) {
                    DBG("Calloc/realloc failed
");
                    return -1;
                }

                // 将分辨率信息添加到pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions中
                pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions[j-1].width = fsenum.discrete.width;
                pglobal->in[id].in_formats[pglobal->in[id].formatCount].supportedResolutions[j-1].height = fsenum.discrete.height;

                // 如果format等于fmtdesc.pixelformat，则将pglobal->in[id].in_formats[pglobal->in[id].formatCount].currentResolution设置为(j - 1)
                if(format == fmtdesc.pixelformat) {
                    pglobal->in[id].in_formats[pglobal->in[id].formatCount].currentResolution = (j - 1);
                    DBG("	Supported size with the current format: %dx%d
", fsenum.discrete.width, fsenum.discrete.height);
                } else {
                    DBG("	Supported size: %dx%d
", fsenum.discrete.width, fsenum.discrete.height);
                }
            } else {
                break;
            }
        }
    }


    /* 为重构图像分配临时缓冲区 */
    vd->framesizeIn = (vd->width * vd->height << 1);
    switch(vd->formatIn) {
    case V4L2_PIX_FMT_MJPEG:
        vd->tmpbuffer = (unsigned char *) calloc(1, (size_t) vd->framesizeIn);
        if(!vd->tmpbuffer)
            goto error;
        vd->framebuffer =
            (unsigned char *) calloc(1, (size_t) vd->width * (vd->height + 8) * 2);
        break;
    case V4L2_PIX_FMT_YUYV:
        vd->framebuffer =
            (unsigned char *) calloc(1, (size_t) vd->framesizeIn);
        break;
    default:
        fprintf(stderr, " should never arrive exit fatal !!
");
        goto error;
        break;

    }

    if(!vd->framebuffer)
        goto error;
    return 0;
error:
    free(pglobal->in[id].in_parameters);
    free(vd->videodevice);
    free(vd->status);
    free(vd->pictName);
    CLOSE_VIDEO(vd->fd);
    return -1;
}

input_init->init_videoIn->init_v4l2代码与初始化V4L2应用程序中的视频输入有关。以下是代码的功能解析：init_v4l2函数用于初始化视频捕获的V4L2接口。使用带有O_RDWR标志的OPEN_VIDEO宏打开指定的视频设备。使用VIDIOC_QUERYCAPioctl查询视频设备的功能。如果查询失败，将打印错误消息，并跳转到fatal标签，表示发生致命错误。使用设备功能的capabilities字段中的V4L2_CAP_VIDEO_CAPTURE标志检查是否支持视频捕获。如果不支持，则打印错误消息，并跳转到fatal标签。根据vd->grabmethod指定的捕获方法，检查设备是否支持流式I/O或读取I/O。如果不支持，将打印错误消息，并跳转到fatal标签。使用VIDIOC_S_FMTioctl设置视频捕获的所需格式。格式参数在vd->fmt结构中设置。如果ioctl调用失败，将打印错误消息，并跳转到fatal标签。如果请求的格式不可用，则根据设备报告的支持格式调整宽度、高度和像素格式。如果调整后的格式不受支持，或者请求的格式为MJPEG并且设备不支持MJPEG模式，或者请求的格式为YUV并且设备不支持YUV模式，则打印错误消息，并跳转到fatal标签。使用VIDIOC_S_PARMioctl设置所需的帧率。帧率在structv4l2_streamparm结构的timeperframe字段中设置。如果ioctl调用失败，则忽略错误，函数继续执行。使用VIDIOC_REQBUFSioctl请求视频缓冲区。请求的缓冲区数量和内存类型在vd->rb结构中设置。如果ioctl调用失败，将打印错误消息，并跳转到fatal标签。使用mmap函数将视频缓冲区映射到应用程序的内存中。每个缓冲区使用从VIDIOC_QUERYBUFioctl获得的缓冲区长度和偏移量进行映射。如果映射失败，将打印错误消息，并跳转到fatal标签。使用VIDIOC_QBUFioctl将映射的缓冲区排队进行视频捕获。索引、类型和内存类型在vd->buf结构中设置。如果排队失败，将打印错误消息，并跳转到fatal标签。

// 初始化视频设备
static int init_v4l2(struct vdIn *vd)
{
    int i;
    int ret = 0;

    // 打开视频设备
    if((vd->fd = OPEN_VIDEO(vd->videodevice, O_RDWR)) == -1) {
        perror("ERROR opening V4L interface");
        DBG("errno: %d", errno);
        return -1;
    }

    // 查询设备信息
    memset(&vd->cap, 0, sizeof(struct v4l2_capability));
    ret = xioctl(vd->fd, VIDIOC_QUERYCAP, &vd->cap);
    if(ret < 0) {
        fprintf(stderr, "Error opening device %s: unable to query device.
", vd->videodevice);
        goto fatal;
    }

    // 判断设备是否支持视频捕获
    if((vd->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
        fprintf(stderr, "Error opening device %s: video capture not supported.
",
                vd->videodevice);
        goto fatal;;
    }

    // 判断设备是否支持流式I/O或读写I/O
    if(vd->grabmethod) {
        if(!(vd->cap.capabilities & V4L2_CAP_STREAMING)) {
            fprintf(stderr, "%s does not support streaming i/o
", vd->videodevice);
            goto fatal;
        }
    } else {
        if(!(vd->cap.capabilities & V4L2_CAP_READWRITE)) {
            fprintf(stderr, "%s does not support read i/o
", vd->videodevice);
            goto fatal;
        }
    }

    /*
     * 设置视频格式
     */
    memset(&vd->fmt, 0, sizeof(struct v4l2_format));
    vd->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置视频流类型
    vd->fmt.fmt.pix.width = vd->width; // 设置视频宽度
    vd->fmt.fmt.pix.height = vd->height; // 设置视频高度
    vd->fmt.fmt.pix.pixelformat = vd->formatIn; // 设置像素格式
    vd->fmt.fmt.pix.field = V4L2_FIELD_ANY; // 设置视频场
    ret = xioctl(vd->fd, VIDIOC_S_FMT, &vd->fmt); // 设置视频格式
    if(ret < 0) {
        fprintf(stderr, "Unable to set format: %d res: %dx%d
", vd->formatIn, vd->width, vd->height);
        goto fatal;
    }

    if((vd->fmt.fmt.pix.width != vd->width) ||
            (vd->fmt.fmt.pix.height != vd->height)) {
        fprintf(stderr, "i: The format asked unavailable, so the width %d height %d 
", vd->fmt.fmt.pix.width, vd->fmt.fmt.pix.height);
        vd->width = vd->fmt.fmt.pix.width;
        vd->height = vd->fmt.fmt.pix.height;
        /*
         * 检查所需格式是否可用
         */
        if(vd->formatIn != vd->fmt.fmt.pix.pixelformat) {
            if(vd->formatIn == V4L2_PIX_FMT_MJPEG) {
                fprintf(stderr, "The inpout device does not supports MJPEG mode
You may also try the YUV mode (-yuv option), but it requires a much more CPU power
");
                goto fatal;
            } else if(vd->formatIn == V4L2_PIX_FMT_YUYV) {
                fprintf(stderr, "The input device does not supports YUV mode
");
                goto fatal;
            }
        } else {
            vd->formatIn = vd->fmt.fmt.pix.pixelformat;
        }
    }

    /*
     * 设置帧率
     */
    struct v4l2_streamparm *setfps;
    setfps = (struct v4l2_streamparm *) calloc(1, sizeof(struct v4l2_streamparm));
    memset(setfps, 0, sizeof(struct v4l2_streamparm));
    setfps->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置视频流类型
    setfps->parm.capture.timeperframe.numerator = 1; // 设置帧率分子
    setfps->parm.capture.timeperframe.denominator = vd->fps; // 设置帧率分母
    ret = xioctl(vd->fd, VIDIOC_S_PARM, setfps); // 设置帧率
    free(setfps);

    /*
     * 请求缓冲区
     */
    memset(&vd->rb, 0, sizeof(struct v4l2_requestbuffers));
    vd->rb.count = NB_BUFFER; // 设置缓冲区数量
    vd->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置视频流类型
    vd->rb.memory = V4L2_MEMORY_MMAP; // 设置内存映射方式

    ret = xioctl(vd->fd, VIDIOC_REQBUFS, &vd->rb); // 请求缓冲区
    if(ret < 0) {
        perror("Unable to allocate buffers");
        goto fatal;
    }

    /*
     * map the buffers
     */
    for(i = 0; i < NB_BUFFER; i++) { // 循环映射缓冲区
        memset(&vd->buf, 0, sizeof(struct v4l2_buffer)); // 清空缓冲区
        vd->buf.index = i; // 设置缓冲区索引
        vd->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置视频流类型
        vd->buf.memory = V4L2_MEMORY_MMAP; // 设置内存映射方式
        ret = xioctl(vd->fd, VIDIOC_QUERYBUF, &vd->buf); // 查询缓冲区
        if(ret < 0) { // 查询失败
            perror("Unable to query buffer"); // 输出错误信息
            goto fatal; // 跳转到错误处理
        }

        if(debug) // 如果是调试模式
            fprintf(stderr, "length: %u offset: %u
", vd->buf.length, vd->buf.m.offset); // 输出缓冲区长度和偏移量

        vd->mem[i] = mmap(0 /* start anywhere */ , // 映射缓冲区
                          vd->buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, vd->fd,
                          vd->buf.m.offset);
        if(vd->mem[i] == MAP_FAILED) { // 映射失败
            perror("Unable to map buffer"); // 输出错误信息
            goto fatal; // 跳转到错误处理
        }
        if(debug) // 如果是调试模式
            fprintf(stderr, "Buffer mapped at address %p.
", vd->mem[i]); // 输出缓冲区映射地址
    }

    /*
     * Queue the buffers.
     */
    for(i = 0; i < NB_BUFFER; ++i) { // 循环将缓冲区加入队列
        memset(&vd->buf, 0, sizeof(struct v4l2_buffer)); // 清空缓冲区
        vd->buf.index = i; // 设置缓冲区索引
        vd->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置视频流类型
        vd->buf.memory = V4L2_MEMORY_MMAP; // 设置内存映射方式
        ret = xioctl(vd->fd, VIDIOC_QBUF, &vd->buf); // 将缓冲区加入队列
        if(ret < 0) { // 加入队列失败
            perror("Unable to queue buffer"); // 输出错误信息
            goto fatal;; // 跳转到错误处理
        }
    }
    return 0;
fatal:
    return -1;

}

启动摄像头输入线程

这个函数是一个摄像头线程函数，主要功能是从摄像头抓取视频帧并进行处理。下面是对函数的概括总结：函数接受一个参数arg，该参数是一个结构体指针context。函数中使用了一个全局变量pglobal，该变量指向pcontext结构体中的全局变量。函数使用pthread_cleanup_push设置了清理处理程序cam_cleanup，以便在函数结束时清理分配的资源。函数通过一个循环来不断抓取视频帧，直到全局变量pglobal的stop标志被设置为真。在抓取视频帧之前，检查视频流的状态是否为暂停状态，如果是暂停状态，则使用usleep函数进行延迟等待。使用uvcGrab函数抓取一帧视频。对于捕获的视频帧，进行一些检查和处理：如果视频帧的大小小于minimum_size，则认为是损坏的帧，跳过处理。如果视频帧的输入格式为V4L2_PIX_FMT_YUYV，则进行YUV到JPEG的压缩处理；否则，直接将视频帧复制到全局缓冲区。复制处理后的帧到全局缓冲区之前，获取全局缓冲区的互斥锁，确保线程安全。将处理后的帧的大小和时间戳复制到全局缓冲区，并通过信号db_update通知其他线程。释放全局缓冲区的互斥锁。根据帧率决定是否使用usleep进行等待，如果帧率低于则等待一定时间，否则直接等待下一帧。当全局变量pglobal的stop标志被设置为真时，退出循环。在函数结束之前，使用pthread_cleanup_pop调用清理处理程序。函数返回NULL。总体而言，该函数负责从摄像头抓取视频帧，并将处理后的帧复制到全局缓冲区，同时控制帧率和处理错误帧。

// 摄像头线程函数
void *cam_thread(void *arg)
{
    context *pcontext = arg;
    pglobal = pcontext->pglobal;

    /* 设置清理处理程序以清理分配的资源 */
    pthread_cleanup_push(cam_cleanup, pcontext);

    while(!pglobal->stop) {
        while(pcontext->videoIn->streamingState == STREAMING_PAUSED) {
            usleep(1); // 可能不是最好的方法，所以FIXME
        }

        /* 抓取一帧 */
        if(uvcGrab(pcontext->videoIn) < 0) {
            IPRINT("Error grabbing frames
");
            exit(EXIT_FAILURE);
        }

        DBG("received frame of size: %d from plugin: %d
", pcontext->videoIn->buf.bytesused, pcontext->id);

        /*
         * Workaround for broken, corrupted frames:
         * Under low light conditions corrupted frames may get captured.
         * The good thing is such frames are quite small compared to the regular pictures.
         * For example a VGA (640x480) webcam picture is normally >= 8kByte large,
         * corrupted frames are smaller.
         */
        if(pcontext->videoIn->buf.bytesused < minimum_size) {
            DBG("dropping too small frame, assuming it as broken
");
            continue;
        }


        /* 将 JPG 图片复制到全局缓冲区 */
        pthread_mutex_lock(&pglobal->in[pcontext->id].db);

        /*
         * 如果以 YUV 模式捕获，则现在将其转换为 JPEG。
         * 此压缩需要许多 CPU 周期，因此尽量避免使用 YUV 格式。
         * 直接从网络摄像头获取 JPEG 是 Linux-UVC 兼容设备的主要优点之一。
         */
        if(pcontext->videoIn->formatIn == V4L2_PIX_FMT_YUYV) {
            DBG("compressing frame from input: %d
", (int)pcontext->id);
            pglobal->in[pcontext->id].size = compress_yuyv_to_jpeg(pcontext->videoIn, pglobal->in[pcontext->id].buf, pcontext->videoIn->framesizeIn, gquality);
        } else {
            DBG("compressing frame from input: %d
", (int)pcontext->id);
            pglobal->in[pcontext->id].size = memcpy_picture(pglobal->in[pcontext->id].buf, pcontext->videoIn->tmpbuffer, pcontext->videoIn->buf.bytesused);
        }

#if 0
        /* 运动检测可以通过比较图片大小来完成，但不是非常准确！！ */
        if((prev_size - global->size)*(prev_size - global->size) > 4 * 1024 * 1024) {
            DBG("检测到运动（差值：%d kB）
", (prev_size - global->size) / 1024);
        }
        prev_size = global->size;
#endif

        /* 将此帧的时间戳复制到用户空间 */
        pglobal->in[pcontext->id].timestamp = pcontext->videoIn->buf.timestamp;

        /* 信号 fresh_frame */
        pthread_cond_broadcast(&pglobal->in[pcontext->id].db_update);
        pthread_mutex_unlock(&pglobal->in[pcontext->id].db);


        /* 只有在 fps 低于 5 时才使用 usleep，否则开销太大 */
        if(pcontext->videoIn->fps < 5) {
            DBG("waiting for next frame for %d us
", 1000 * 1000 / pcontext->videoIn->fps);
            usleep(1000 * 1000 / pcontext->videoIn->fps);
        } else {
            DBG("waiting for next frame
");
        }
    }

    DBG("leaving input thread, calling cleanup function now
");
    pthread_cleanup_pop(1);

    return NULL;
}

这段代码是用于从视频设备中抓取一帧视频的函数uvcGrab。以下是对函数的概括总结：函数接受一个参数vd，该参数是一个指向structvdIn结构体的指针。首先检查视频流的状态，如果当前状态为关闭状态，则通过调用video_enable函数启动视频流。将缓冲区vd->buf清零，并设置缓冲区的类型为视频捕获，内存类型为内存映射。使用xioctl函数从队列中取出一个缓冲区，存储在vd->buf中。根据输入的格式进行处理：如果输入格式为V4L2_PIX_FMT_MJPEG，检查当前缓冲区的大小是否小于等于HEADERFRAME如果是，则输出警告信息并返回。将缓冲区的内容复制到临时缓冲区vd->tmpbuffer。如果输入格式为V4L2_PIX_FMT_YUYV，将缓冲区的内容复制到帧缓冲区vd->framebuffer，根据实际大小进行复制。对于其他输入格式，跳转到错误处理。使用xioctl函数将缓冲区重新放入队列。如果发生错误，设置退出信号为0，并返回-函数正常执行完成后，返回0。该函数的主要目的是从视频设备中获取一帧视频数据，并根据输入格式进行相应处理和复制。

int uvcGrab(struct vdIn *vd)
{
#define HEADERFRAME1 0xaf
    int ret;

    if(vd->streamingState == STREAMING_OFF) { // 如果当前状态为关闭状态
        if(video_enable(vd)) // 启动视频流
            goto err;
    }
    memset(&vd->buf, 0, sizeof(struct v4l2_buffer)); // 将缓冲区清零
    vd->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置缓冲区类型为视频捕获
    vd->buf.memory = V4L2_MEMORY_MMAP; // 设置缓冲区内存类型为内存映射

    ret = xioctl(vd->fd, VIDIOC_DQBUF, &vd->buf); // 从队列中取出缓冲区
    if(ret < 0) { // 取出失败
        perror("Unable to dequeue buffer"); // 输出错误信息
        goto err; // 跳转到错误处理
    }

    switch(vd->formatIn) { // 根据输入格式进行处理
    case V4L2_PIX_FMT_MJPEG: // 如果是MJPEG格式
        if(vd->buf.bytesused <= HEADERFRAME1) { // 如果当前缓冲区大小小于等于0xaf
            /* Prevent crash
                                                        * on empty image */
            fprintf(stderr, "Ignoring empty buffer ...
"); // 输出警告信息
            return 0; // 返回0
        }

        /* memcpy(vd->tmpbuffer, vd->mem[vd->buf.index], vd->buf.bytesused);

        memcpy (vd->tmpbuffer, vd->mem[vd->buf.index], HEADERFRAME1);
        memcpy (vd->tmpbuffer + HEADERFRAME1, dht_data, sizeof(dht_data));
        memcpy (vd->tmpbuffer + HEADERFRAME1 + sizeof(dht_data), vd->mem[vd->buf.index] + HEADERFRAME1, (vd->buf.bytesused - HEADERFRAME1));
        */

        memcpy(vd->tmpbuffer, vd->mem[vd->buf.index], vd->buf.bytesused); // 将缓冲区内容复制到临时缓冲区

        if(debug)
            fprintf(stderr, "bytes in used %d 
", vd->buf.bytesused); // 输出调试信息
        break;

    case V4L2_PIX_FMT_YUYV: // 如果是YUYV格式
        if(vd->buf.bytesused > vd->framesizeIn)
            memcpy(vd->framebuffer, vd->mem[vd->buf.index], (size_t) vd->framesizeIn); // 将缓冲区内容复制到帧缓冲区
        else
            memcpy(vd->framebuffer, vd->mem[vd->buf.index], (size_t) vd->buf.bytesused); // 将缓冲区内容复制到帧缓冲区
        break;

    default:
        goto err; // 跳转到错误处理
        break;
    }

    ret = xioctl(vd->fd, VIDIOC_QBUF, &vd->buf); // 将缓冲区加入队列
    if(ret < 0) { // 加入队列失败
        perror("Unable to requeue buffer"); // 输出错误信息
        goto err; // 跳转到错误处理
    }

    return 0; // 返回0

err:
    vd->signalquit = 0; // 设置退出信号为0
    return -1; // 返回-1
}


// 启用视频流
static int video_enable(struct vdIn *vd)
{
    int type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // 设置视频流类型
    int ret;

    ret = xioctl(vd->fd, VIDIOC_STREAMON, &type); // 启用视频流
    if(ret < 0) { // 启用失败
        perror("Unable to start capture"); // 输出错误信息
        return ret; // 返回错误码
    }
    vd->streamingState = STREAMING_ON; // 设置视频流状态为开启
    return 0; // 返回成功
}

这段代码是用于将YUYV格式的帧数据压缩为JPEG格式的函数compress_yuyv_to_jpeg。以下是对函数的概括总结：函数接受四个参数：指向structvdIn结构体的指针vd，存储压缩后数据的缓冲区buffer，缓冲区大小size，以及压缩的质量quality。首先分配一行像素数据的缓冲区line_buffer，并获取YUYV格式的帧数据存储在yuyv中。初始化JPEG压缩结构体cinfo和JPEG错误管理器jerr。将压缩后的数据存储到内存中的buffer中，通过调用dest_buffer函数来实现，同时记录已经写入的字节数。设置像的宽度、高度、颜色空间等信息。设置JPEG压缩参数，包括压缩质量。开始压缩过程，调用jpeg_start_compress函数。遍历每一行像素数据：遍历每个像素点，根据YUV值计算对应的RGB值。将RGB值存储到line_buffer中。更新YUV值。存储一行像素数据，通过调用jpeg_write_scanlines函数实现。压缩结束后，调用jpeg_finish_compress完成压缩过程。销毁JPEG压缩结构体，通过调用jpeg_destroy_compress函数。释放缓冲区line_buffer。返回已经写入的字节数。该函数使用libjpeg库将YUYV格式的帧数据压缩为JPEG格式，并将压缩后的数据存储在指定的缓冲区中，并返回已经写入的字节数。

int compress_yuyv_to_jpeg(struct vdIn *vd, unsigned char *buffer, int size, int quality)
{
    // 初始化jpeg压缩结构体
    struct jpeg_compress_struct cinfo;
    // 初始化jpeg错误管理器
    struct jpeg_error_mgr jerr;
    // 存储一行像素数据
    JSAMPROW row_pointer[1];
    // 存储一行像素数据的缓冲区
    unsigned char *line_buffer, *yuyv;
    // 计数器
    int z;
    // 已经写入的字节数
    static int written;

    // 分配一行像素数据的缓冲区
    line_buffer = calloc(vd->width * 3, 1);
    // 获取YUYV格式的帧缓冲区
    yuyv = vd->framebuffer;

    // 初始化jpeg错误管理器
    cinfo.err = jpeg_std_error(&jerr);
    // 创建jpeg压缩结构体
    jpeg_create_compress(&cinfo);
    // 将压缩后的数据存储到内存中
    dest_buffer(&cinfo, buffer, size, &written);

    // 设置图像的宽、高、颜色空间等信息
    cinfo.image_width = vd->width;
    cinfo.image_height = vd->height;
    cinfo.input_components = 3;
    cinfo.in_color_space = JCS_RGB;

    // 设置jpeg压缩参数
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, quality, TRUE);

    // 开始压缩
    jpeg_start_compress(&cinfo, TRUE);

    // 遍历每一行像素数据
    z = 0;
    while(cinfo.next_scanline < vd->height) {
        int x;
        unsigned char *ptr = line_buffer;

        // 遍历每一个像素点
        for(x = 0; x < vd->width; x++) {
            int r, g, b;
            int y, u, v;

            // 获取YUV值
            if(!z)
                y = yuyv[0] << 8;
            else
                y = yuyv[2] << 8;
            u = yuyv[1] - 128;
            v = yuyv[3] - 128;

            // 转换为RGB值
            r = (y + (359 * v)) >> 8;
            g = (y - (88 * u) - (183 * v)) >> 8;
            b = (y + (454 * u)) >> 8;

            // 存储RGB值
            *(ptr++) = (r > 255) ? 255 : ((r < 0) ? 0 : r);
            *(ptr++) = (g > 255) ? 255 : ((g < 0) ? 0 : g);
            *(ptr++) = (b > 255) ? 255 : ((b < 0) ? 0 : b);

            // 更新YUV值
            if(z++) {
                z = 0;
                yuyv += 4;
            }
        }

        // 存储一行像素数据
        row_pointer[0] = line_buffer;
        jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    // 压缩结束
    jpeg_finish_compress(&cinfo);
    // 销毁jpeg压缩结构体
    jpeg_destroy_compress(&cinfo);

    // 释放缓冲区
    free(line_buffer);

    // 返回已经写入的字节数
    return (written);
}

这段代码是用于复制像数据的函数memcpy_picture。以下是对函数的概括总结：函数接受三个参数：目标缓冲区out，源数据缓冲区buf，以及源数据大小size。首先检查源数据是否使用哈夫曼编码，通过调用is_huffman函数来判断。如果源数据不是哈夫曼编码：初始化指针ptdeb、ptlimit和ptcur，分别指向源数据的起始位置、结束位置和当前位置。在源数据中查找标识为0xffc0的位置，表示像数据的起始。如果没有找到标识，说明源数据不完整，函数返回当前位置pos。计算需要复制的前半部分的大小sizein。将前半部分复制到目标缓冲区out中，并更新pos。将DHT数据复制到目标缓冲区out中，并更新pos。将后半部分复制到目标缓冲区out中，并更新pos。如果源数据使用哈夫曼编码：将源数据直接复制到目标缓冲区out中，并更新pos。返回当前位置pos。该函数用于将像数据复制到目标缓冲区，并根据是否使用哈夫曼编码进行相应的处理。如果源数据不完整或者不是哈夫曼编码，函数将返回当前复制的位置，否则返回复制完成后的位置。

// 复制图片
int memcpy_picture(unsigned char *out, unsigned char *buf, int size)
{
    unsigned char *ptdeb, *ptlimit, *ptcur = buf;
    int sizein, pos = 0;

    if(!is_huffman(buf)) { // 如果不是哈夫曼编码
        ptdeb = ptcur = buf; // 设置起始位置
        ptlimit = buf + size; // 设置结束位置
        while((((ptcur[0] << 8) | ptcur[1]) != 0xffc0) && (ptcur < ptlimit)) // 查找0xffc0
            ptcur++; // 移动指针
        if(ptcur >= ptlimit) // 如果指针超出范围
            return pos; // 返回当前位置
        sizein = ptcur - ptdeb; // 计算需要复制的大小

        memcpy(out + pos, buf, sizein); pos += sizein; // 复制前半部分
        memcpy(out + pos, dht_data, sizeof(dht_data)); pos += sizeof(dht_data); // 复制DHT数据
        memcpy(out + pos, ptcur, size - sizein); pos += size - sizein; // 复制后半部分
    } else { // 如果是哈夫曼编码
        memcpy(out + pos, ptcur, size); pos += size; // 直接复制
    }
    return pos; // 返回当前位置

输出初始化output_init

该函数接受两个参数：一个名为param的指向output_parameter结构体的指针和一个整数id。以下是代码的执行过程：初始化变量：port被设为htons的结果，将端口号转换为网络字节顺序。credentials和www_folder被设为NULL。nocommands被设为0。使用DBG宏打印调试信息，指示输出编号。将param->argv的第一个元素设为OUTPUT_PLUGIN_NAME。使用getopt_long_only循环遍历命令行选项：如果遇到无法识别的选项，调用help函数并返回否则，根据option_index的值进行切换：Case0和使用help函数打印帮助信息并返回Case2和解析端口选项，将提供的值转换为网络字节顺序后设置给port。Case4和解析凭证选项，为credentials分配内存并复制提供的值。Case6和解析WWW选项，为www_folder分配内存并复制提供的值。如果值不以斜杠结尾，则添加斜杠。Case8和将nocommands设为表示禁用命令。根据解析的选项设置服务器的配置值：将servers[param->id].id设为param->id。将servers[param->id].pglobal设为param->global。将servers[param->id].conf.port设为port。将servers[param->id].conf.credentials设为credentials。将servers[param->id].conf.www_folder设为www_folder。将servers[param->id].conf.nocommands设为nocommands。使用OPRINT宏打印配置值。返回0表示初始化成功。

int output_init(output_parameter *param, int id)
{
    int i;
    int  port;
    char *credentials, *www_folder;
    char nocommands;

    DBG("output #%02d
", param->id);

    port = htons(8080);
    credentials = NULL;
    www_folder = NULL;
    nocommands = 0;

    param->argv[0] = OUTPUT_PLUGIN_NAME;

    /* show all parameters for DBG purposes */
    for(i = 0; i < param->argc; i++) {
        DBG("argv[%d]=%s
", i, param->argv[i]);
    }

    reset_getopt();
    while(1) {
        int option_index = 0, c = 0;
        static struct option long_options[] = {
            {"h", no_argument, 0, 0
            },
            {"help", no_argument, 0, 0},
            {"p", required_argument, 0, 0},
            {"port", required_argument, 0, 0},
            {"c", required_argument, 0, 0},
            {"credentials", required_argument, 0, 0},
            {"w", required_argument, 0, 0},
            {"www", required_argument, 0, 0},
            {"n", no_argument, 0, 0},
            {"nocommands", no_argument, 0, 0},
            {0, 0, 0, 0}
        };

        c = getopt_long_only(param->argc, param->argv, "", long_options, &option_index);

        /* no more options to parse */
        if(c == -1) break;

        /* unrecognized option */
        if(c == "?") {
            help();
            return 1;
        }

        switch(option_index) {
            /* h, help */
        case 0:
        case 1:
            DBG("case 0,1
");
            help();
            return 1;
            break;

            /* p, port */
        case 2:
        case 3:
            DBG("case 2,3
");
            port = htons(atoi(optarg));
            break;

            /* c, credentials */
        case 4:
        case 5:
            DBG("case 4,5
");
            credentials = strdup(optarg);
            break;

            /* w, www */
        case 6:
        case 7:
            DBG("case 6,7
");
            www_folder = malloc(strlen(optarg) + 2);
            strcpy(www_folder, optarg);
            if(optarg[strlen(optarg)-1] != "/")
                strcat(www_folder, "/");
            break;

            /* n, nocommands */
        case 8:
        case 9:
            DBG("case 8,9
");
            nocommands = 1;
            break;
        }
    }

    servers[param->id].id = param->id;
    servers[param->id].pglobal = param->global;
    servers[param->id].conf.port = port;
    servers[param->id].conf.credentials = credentials;
    servers[param->id].conf.www_folder = www_folder;
    servers[param->id].conf.nocommands = nocommands;

    OPRINT("www-folder-path...: %s
", (www_folder == NULL) ? "disabled" : www_folder);
    OPRINT("HTTP TCP port.....: %d
", ntohs(port));
    OPRINT("username:password.: %s
", (credentials == NULL) ? "disabled" : credentials);
    OPRINT("commands..........: %s
", (nocommands) ? "disabled" : "enabled");
    return 0;
}

启动摄像头输出线程

服务器线程函数，用于接受客户端的连接请求并创建子线程处理每个客户端连接。下面是代码的主要步骤：初始化变量和数据结构。获取服务器地址信息，包括IP地址和端口号。创建套接字，并设置套接字选项。绑定套接字到服务器地址。监听套接字，等待客户端连接。循环等待客户端连接请求，使用select函数等待可读套接字。当有客户端连接时，创建一个子线程来处理连接。子线程通过调用accept函数接受客户端连接，并传递连接套接字和上下文信息给子线程。在子线程中处理客户端请求和响应。主线程继续等待下一个客户端连接。当收到停止信号时，退出循环，关闭套接字，并执行清理函数。

// 服务器线程函数
void *server_thread(void *arg)
{
    int on;
    pthread_t client;
    struct addrinfo *aip, *aip2;
    struct addrinfo hints;
    struct sockaddr_storage client_addr;
    socklen_t addr_len = sizeof(struct sockaddr_storage);
    fd_set selectfds;
    int max_fds = 0;
    char name[NI_MAXHOST];
    int err;
    int i;

    context *pcontext = arg;
    pglobal = pcontext->pglobal;

    /* set cleanup handler to cleanup ressources */
    pthread_cleanup_push(server_cleanup, pcontext);

    // 初始化hints结构体
    bzero(&hints, sizeof(hints));
    hints.ai_family = PF_UNSPEC; // 支持IPv4和IPv6
    hints.ai_flags = AI_PASSIVE; // 用于bind函数，表示返回的套接字地址结构体中的IP地址是通配地址
    hints.ai_socktype = SOCK_STREAM; // TCP协议

    // 获取地址信息
    snprintf(name, sizeof(name), "%d", ntohs(pcontext->conf.port)); // 将端口号转换为字符串
    if((err = getaddrinfo(NULL, name, &hints, &aip)) != 0) { // 获取地址信息
        perror(gai_strerror(err)); // 输出错误信息
        exit(EXIT_FAILURE); // 退出程序
    }

    // 初始化所有套接字为-1
    for(i = 0; i < MAX_SD_LEN; i++)
        pcontext->sd[i] = -1;

    /* open sockets for server (1 socket / address family) */
    i = 0;
    for(aip2 = aip; aip2 != NULL; aip2 = aip2->ai_next) {
        if((pcontext->sd[i] = socket(aip2->ai_family, aip2->ai_socktype, 0)) < 0) { // 创建套接字
            continue;
        }

        /* ignore "socket already in use" errors */
        on = 1;
        if(setsockopt(pcontext->sd[i], SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { // 设置套接字选项
            perror("setsockopt(SO_REUSEADDR) failed");
        }

        /* IPv6 socket should listen to IPv6 only, otherwise we will get "socket already in use" */
        on = 1;
        if(aip2->ai_family == AF_INET6 && setsockopt(pcontext->sd[i], IPPROTO_IPV6, IPV6_V6ONLY,
                (const void *)&on , sizeof(on)) < 0) { // 设置套接字选项
            perror("setsockopt(IPV6_V6ONLY) failed");
        }

        /* perhaps we will use this keep-alive feature oneday */
        /* setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)); */

        if(bind(pcontext->sd[i], aip2->ai_addr, aip2->ai_addrlen) < 0) { // 绑定套接字
            perror("bind");
            pcontext->sd[i] = -1;
            continue;
        }

        if(listen(pcontext->sd[i], 10) < 0) { // 监听套接字
            perror("listen");
            pcontext->sd[i] = -1;
        } else {
            i++;
            if(i >= MAX_SD_LEN) {
                OPRINT("%s(): maximum number of server sockets exceeded", __FUNCTION__);
                i--;
                break;
            }
        }
    }


    pcontext->sd_len = i;

    if(pcontext->sd_len < 1) { // 如果没有套接字绑定成功，程序退出
        OPRINT("%s(): bind(%d) failed", __FUNCTION__, htons(pcontext->conf.port));
        closelog();
        exit(EXIT_FAILURE);
    }

    /* create a child for every client that connects */
    while(!pglobal->stop) { // 循环等待客户端连接
        //int *pfd = (int *)malloc(sizeof(int));
        cfd *pcfd = malloc(sizeof(cfd)); // 分配内存

        if(pcfd == NULL) { // 如果分配内存失败，程序退出
            fprintf(stderr, "failed to allocate (a very small amount of) memory
");
            exit(EXIT_FAILURE);
        }

        DBG("waiting for clients to connect
"); // 输出调试信息

        do { // 循环等待客户端连接
            FD_ZERO(&selectfds); // 清空文件描述符集合

            for(i = 0; i < MAX_SD_LEN; i++) { // 将所有套接字加入文件描述符集合
                if(pcontext->sd[i] != -1) {
                    FD_SET(pcontext->sd[i], &selectfds);

                    if(pcontext->sd[i] > max_fds)
                        max_fds = pcontext->sd[i];
                }
            }

            err = select(max_fds + 1, &selectfds, NULL, NULL, NULL); // 等待客户端连接

            if(err < 0 && errno != EINTR) { // 如果出错，程序退出
                perror("select");
                exit(EXIT_FAILURE);
            }
        } while(err <= 0); // 如果没有客户端连接，继续等待

        for(i = 0; i < max_fds + 1; i++) {
            if(pcontext->sd[i] != -1 && FD_ISSET(pcontext->sd[i], &selectfds)) {
                pcfd->fd = accept(pcontext->sd[i], (struct sockaddr *)&client_addr, &addr_len);
                pcfd->pc = pcontext;

                /* start new thread that will handle this TCP connected client */
                DBG("create thread to handle client that just established a connection
");

#if 0
/* commented out as it fills up syslog with many redundant entries */

                if(getnameinfo((struct sockaddr *)&client_addr, addr_len, name, sizeof(name), NULL, 0, NI_NUMERICHOST) == 0) {
                    syslog(LOG_INFO, "serving client: %s
", name);
                }
#endif

                if(pthread_create(&client, NULL, &client_thread, pcfd) != 0) { // 创建线程处理客户端连接
                    DBG("could not launch another client thread
");
                    close(pcfd->fd);
                    free(pcfd);
                    continue;
                }
                pthread_detach(client); // 分离线程
            }
        }
    }

    DBG("leaving server thread, calling cleanup function now
");
    pthread_cleanup_pop(1); // 弹出清理函数

    return NULL;

}

设置SO_REUSEADDR选项。

该选项允许在套接字关闭后立即重新使用相同的地址。通过设置SO_REUSEADDR选项，可以在套接字关闭后，立即重新使用相同的地址，而不需要等待操作系统释放该地址的等待时间。这在处理服务器应用程序时很常见，因为服务器通常会频繁地启动和关闭，并在相同的地址上监听连接。

/* ignore "socket already in use" errors */
on = 1;
if(setsockopt(pcontext->sd[i], SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { // 设置套接字选项
    perror("setsockopt(SO_REUSEADDR) failed");
}

设置IPV6_V6ONLY选项。

该选项用于在IPv6套接字上限制仅接受IPv6连接，以避免IPv4连接进入IPv6套接字。通过设置IPV6_V6ONLY选项，可以确保IPv6套接字仅接受IPv6连接，防止IPv4连接进入该套接字。这对于处理同时支持IPv4和IPv6的服务器应用程序非常重要，以确保连接按照正确的协议进行处理。

/* IPv6 socket should listen to IPv6 only, otherwise we will get "socket already in use" */
on = 1;
if(aip2->ai_family == AF_INET6 && setsockopt(pcontext->sd[i], IPPROTO_IPV6, IPV6_V6ONLY,
        (const void *)&on , sizeof(on)) < 0) { // 设置套接字选项
    perror("setsockopt(IPV6_V6ONLY) failed");
}

绑定地址/开始监听

通过bind函数将套接字与指定地址绑定，并使用listen函数开始监听连接请求。

   /* perhaps we will use this keep-alive feature oneday */
    /* setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)); */

    if(bind(pcontext->sd[i], aip2->ai_addr, aip2->ai_addrlen) < 0) { // 绑定套接字
        perror("bind");
        pcontext->sd[i] = -1;
        continue;
    }

    if(listen(pcontext->sd[i], 10) < 0) { // 监听套接字
        perror("listen");
        pcontext->sd[i] = -1;
    } else {
        i++;
        if(i >= MAX_SD_LEN) {
            OPRINT("%s(): maximum number of server sockets exceeded", __FUNCTION__);
            i--;
            break;
        }
    }



/* create a child for every client that connects */
while(!pglobal->stop) { // 循环等待客户端连接
    //int *pfd = (int *)malloc(sizeof(int));
    cfd *pcfd = malloc(sizeof(cfd)); // 分配内存

    if(pcfd == NULL) { // 如果分配内存失败，程序退出
        fprintf(stderr, "failed to allocate (a very small amount of) memory
");
        exit(EXIT_FAILURE);
    }

    DBG("waiting for clients to connect
"); // 输出调试信息

    do { // 循环等待客户端连接
        FD_ZERO(&selectfds); // 清空文件描述符集合

        for(i = 0; i < MAX_SD_LEN; i++) { // 将所有套接字加入文件描述符集合
            if(pcontext->sd[i] != -1) {
                FD_SET(pcontext->sd[i], &selectfds);

                if(pcontext->sd[i] > max_fds)
                    max_fds = pcontext->sd[i];
            }
        }

        err = select(max_fds + 1, &selectfds, NULL, NULL, NULL); // 等待客户端连接

        if(err < 0 && errno != EINTR) { // 如果出错，程序退出
            perror("select");
            exit(EXIT_FAILURE);
        }
    } while(err <= 0); // 如果没有客户端连接，继续等待

等待客户端连接

当有客户端连接请求到达时，将会创建一个子进程来处理该连接。这段代码使用select函数来实现非阻塞的等待，并通过文件描述符集合selectfds来管理待监听的套接字。

 do { // 循环等待客户端连接
        FD_ZERO(&selectfds); // 清空文件描述符集合

        for(i = 0; i < MAX_SD_LEN; i++) { // 将所有套接字加入文件描述符集合
            if(pcontext->sd[i] != -1) {
                FD_SET(pcontext->sd[i], &selectfds);

                if(pcontext->sd[i] > max_fds)
                    max_fds = pcontext->sd[i];
            }
        }

        err = select(max_fds + 1, &selectfds, NULL, NULL, NULL); // 等待客户端连接

        if(err < 0 && errno != EINTR) { // 如果出错，程序退出
            perror("select");
            exit(EXIT_FAILURE);
        }
        } while(err <= 0); // 如果没有客户端连接，继续等待

处理与客户端建立的连接。

对于每个就绪的套接字，它会创建一个新线程来处理客户端连接，并将相关的套接字和上下文信息传递给线程函数。线程函数client_thread负责实际处理客户端连接的逻辑。主线程继续循环等待并处理更多的连接请求。

       for(i = 0; i < max_fds + 1; i++) {
            if(pcontext->sd[i] != -1 && FD_ISSET(pcontext->sd[i], &selectfds)) {
                pcfd->fd = accept(pcontext->sd[i], (struct sockaddr *)&client_addr, &addr_len);
                pcfd->pc = pcontext;

                /* start new thread that will handle this TCP connected client */
                DBG("create thread to handle client that just established a connection
");

#if 0
/* commented out as it fills up syslog with many redundant entries */

                if(getnameinfo((struct sockaddr *)&client_addr, addr_len, name, sizeof(name), NULL, 0, NI_NUMERICHOST) == 0) {
                    syslog(LOG_INFO, "serving client: %s
", name);
                }
#endif

                if(pthread_create(&client, NULL, &client_thread, pcfd) != 0) { // 创建线程处理客户端连接
                    DBG("could not launch another client thread
");
                    close(pcfd->fd);
                    free(pcfd);
                    continue;
                }
                pthread_detach(client); // 分离线程
            }
        }
    }

这段代码是一个HTTP客户端线程的函数实现。它接收一个指向cfd结构的指针作为参数，然后进行一系列的操作来处理客户端的请求。以下是代码的主要流程：初始化变量和数据结构。读取客户端的请求行。根据请求行确定请求的类型，并设置相应的标记。解析HTTP请求的其余部分，包括请求头和可选的用户名密码验证信息。检查用户名和密码是否匹配配置文件中的设置。根据请求类型处理请求，可能涉及发送快照、发送流、执行命令、发送插件描述符JSON文件或发送文件等操作。关闭文件描述符，释放请求相关的内存。需要注意的是，代码中的部分逻辑可能与具体的应用程序有关，例如根据配置文件限制命令的执行或检查输入编号的范围等。

/* thread for clients that connected to this server */
void *client_thread(void *arg)
{
    int cnt;
    char input_suffixed = 0;
    int input_number = 0;
    char buffer[BUFFER_SIZE] = {0}, *pb = buffer;
    iobuffer iobuf;
    request req;
    cfd lcfd; /* local-connected-file-descriptor */

    /* we really need the fildescriptor and it must be freeable by us */ // 我们确实需要文件描述符，并且它必须由我们释放
    if(arg != NULL) {
        memcpy(&lcfd, arg, sizeof(cfd));
        free(arg);
    } else
        return NULL;

    /* initializes the structures */ // 初始化结构体
    init_iobuffer(&iobuf);
    init_request(&req);

    /* What does the client want to receive? Read the request. */ // 客户端想要接收什么？读取请求
    memset(buffer, 0, sizeof(buffer));
    if((cnt = _readline(lcfd.fd, &iobuf, buffer, sizeof(buffer) - 1, 5)) == -1) { // 读取请求行
        close(lcfd.fd);
        return NULL;
    }



    /* 确定要提供什么 */
    if(strstr(buffer, "GET /?action=snapshot") != NULL) { // 如果请求是获取快照
        req.type = A_SNAPSHOT; // 设置请求类型为获取快照
#ifdef WXP_COMPAT
    } else if((strstr(buffer, "GET /cam") != NULL) && (strstr(buffer, ".jpg") != NULL)) { // 如果请求是获取jpg格式的快照
        req.type = A_SNAPSHOT; // 设置请求类型为获取快照
#endif
        input_suffixed = 255; // 标记请求中是否包含插件编号
    } else if(strstr(buffer, "GET /?action=stream") != NULL) { // 如果请求是获取流
        input_suffixed = 255; // 标记请求中是否包含插件编号
        req.type = A_STREAM; // 设置请求类型为获取流
#ifdef WXP_COMPAT
    } else if((strstr(buffer, "GET /cam") != NULL) && (strstr(buffer, ".mjpg") != NULL)) { // 如果请求是获取mjpg格式的流
        req.type = A_STREAM; // 设置请求类型为获取流
#endif
        input_suffixed = 255; // 标记请求中是否包含插件编号
    } else if((strstr(buffer, "GET /input") != NULL) && (strstr(buffer, ".json") != NULL)) { // 如果请求是获取输入插件的json格式数据
        req.type = A_INPUT_JSON; // 设置请求类型为获取输入插件的json格式数据
        input_suffixed = 255; // 标记请求中是否包含插件编号
    } else if((strstr(buffer, "GET /output") != NULL) && (strstr(buffer, ".json") != NULL)) { // 如果请求是获取输出插件的json格式数据
        req.type = A_OUTPUT_JSON; // 设置请求类型为获取输出插件的json格式数据
        input_suffixed = 255; // 标记请求中是否包含插件编号
    } else if(strstr(buffer, "GET /program.json") != NULL) { // 如果请求是获取程序的json格式数据
        req.type = A_PROGRAM_JSON; // 设置请求类型为获取程序的json格式数据
        input_suffixed = 255; // 标记请求中是否包含插件编号
    } else if(strstr(buffer, "GET /?action=command") != NULL) {
        int len;
        req.type = A_COMMAND;

        /* advance by the length of known string */
        if((pb = strstr(buffer, "GET /?action=command")) == NULL) { // 如果请求不是获取命令
            DBG("HTTP request seems to be malformed
"); // 输出调试信息
            send_error(lcfd.fd, 400, "Malformed HTTP request"); // 发送错误信息
            close(lcfd.fd); // 关闭文件描述符
            return NULL; // 返回空指针
        }
        pb += strlen("GET /?action=command"); // a pb points to thestring after the first & after command

        /* only accept certain characters */ // 只接受特定字符
        len = MIN(MAX(strspn(pb, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-=&1234567890%./"), 0), 100); // 计算参数长度

        req.parameter = malloc(len + 1); // 分配参数内存
        if(req.parameter == NULL) { // 如果分配失败
            exit(EXIT_FAILURE); // 退出程序
        }
        memset(req.parameter, 0, len + 1); // 清空参数内存
        strncpy(req.parameter, pb, len); // 复制参数

        if(unescape(req.parameter) == -1) { // 如果解码失败
            free(req.parameter); // 释放参数内存
            send_error(lcfd.fd, 500, "could not properly unescape command parameter string"); // 发送错误信息
            LOG("could not properly unescape command parameter string
"); // 输出调试信息
            close(lcfd.fd); // 关闭文件描述符
            return NULL; // 返回空指针
        }

        DBG("command parameter (len: %d): "%s"
", len, req.parameter); // 输出调试信息
    } else {
        int len;

        DBG("try to serve a file
"); // 输出调试信息
        req.type = A_FILE; // 设置请求类型为获取文件

        if((pb = strstr(buffer, "GET /")) == NULL) { // 如果请求不是获取文件
            DBG("HTTP request seems to be malformed
"); // 输出调试信息
            send_error(lcfd.fd, 400, "Malformed HTTP request"); // 发送错误信息
            close(lcfd.fd); // 关闭文件描述符
            return NULL; // 返回空指针
        }

        pb += strlen("GET /"); // 跳过"GET /"
        len = MIN(MAX(strspn(pb, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ._-1234567890"), 0), 100); // 计算参数长度
        req.parameter = malloc(len + 1); // 分配参数内存
        if(req.parameter == NULL) { // 如果分配失败
            exit(EXIT_FAILURE); // 退出程序
        }
        memset(req.parameter, 0, len + 1); // 清空参数内存
        strncpy(req.parameter, pb, len); // 复制参数

        DBG("parameter (len: %d): "%s"
", len, req.parameter); // 输出调试信息
    }

    /*
     * 当我们使用多个输入插件时，有些url可能会有一个_[插件编号后缀]
     * 为了兼容性，可以在这种情况下保留，输出将从第0个输入插件生成
     */
    if(input_suffixed) {
        char *sch = strchr(buffer, "_");
        if(sch != NULL) {  // 如果url中有_，则输入编号应该存在
            DBG("sch %s
", sch + 1); // FIXME 如果添加了超过10个输入插件
            char numStr[3];
            memset(numStr, 0, 3);
            strncpy(numStr, sch + 1, 1);
            input_number = atoi(numStr);
        }
        DBG("input plugin_no: %d
", input_number);
    }

    /*
     * 解析HTTP请求的其余部分
     * 请求头的结尾由一个单独的空行"
"标记
     */
    do {
        memset(buffer, 0, sizeof(buffer));

        if((cnt = _readline(lcfd.fd, &iobuf, buffer, sizeof(buffer) - 1, 5)) == -1) {
            free_request(&req);
            close(lcfd.fd);
            return NULL;
        }

        if(strstr(buffer, "User-Agent: ") != NULL) {
            req.client = strdup(buffer + strlen("User-Agent: "));
        } else if(strstr(buffer, "Authorization: Basic ") != NULL) {
            req.credentials = strdup(buffer + strlen("Authorization: Basic "));
            decodeBase64(req.credentials);
            DBG("username:password: %s
", req.credentials);
        }

    } while(cnt > 2 && !(buffer[0] == "
" && buffer[1] == "
"));

    /* 如果给出了参数-c，则检查用户名和密码 */
    if(lcfd.pc->conf.credentials != NULL) {
        if(req.credentials == NULL || strcmp(lcfd.pc->conf.credentials, req.credentials) != 0) {
            DBG("access denied
");
            send_error(lcfd.fd, 401, "username and password do not match to configuration");
            close(lcfd.fd);
            if(req.parameter != NULL) free(req.parameter);
            if(req.client != NULL) free(req.client);
            if(req.credentials != NULL) free(req.credentials);
            return NULL;
        }
        DBG("access granted
");
    }


    /* 现在是回应请求的时候 */

    if(!(input_number < pglobal->incnt)) { // 如果输入编号超出范围
        DBG("Input number: %d out of range (valid: 0..%d)
", input_number, pglobal->incnt-1); // 输出调试信息
        send_error(lcfd.fd, 404, "Invalid input plugin number"); // 发送错误信息
        req.type = A_UNKNOWN; // 设置请求类型为未知
    }

    switch(req.type) { // 根据请求类型进行处理
    case A_SNAPSHOT: // 请求快照
        DBG("Request for snapshot from input: %d
", input_number); // 输出调试信息
        send_snapshot(lcfd.fd, input_number); // 发送快照
        break;
    case A_STREAM: // 请求流
        DBG("Request for stream from input: %d
", input_number); // 输出调试信息
        send_stream(lcfd.fd, input_number); // 发送流
        break;
    case A_COMMAND: // 请求命令
        if(lcfd.pc->conf.nocommands) { // 如果不允许命令
            send_error(lcfd.fd, 501, "this server is configured to not accept commands"); // 发送错误信息
            break;
        }
        command(lcfd.pc->id, lcfd.fd, req.parameter); // 执行命令
        break;
    case A_INPUT_JSON: // 请求输入插件描述符JSON文件
        DBG("Request for the Input plugin descriptor JSON file
"); // 输出调试信息
        send_Input_JSON(lcfd.fd, input_number); // 发送输入插件描述符JSON文件
        break;
    case A_OUTPUT_JSON: // 请求输出插件描述符JSON文件
        DBG("Request for the Output plugin descriptor JSON file
"); // 输出调试信息
        send_Output_JSON(lcfd.fd, input_number); // 发送输出插件描述符JSON文件
        break;
    case A_PROGRAM_JSON: // 请求程序描述符JSON文件
        DBG("Request for the program descriptor JSON file
"); // 输出调试信息
        send_Program_JSON(lcfd.fd); // 发送程序描述符JSON文件
        break;
    case A_FILE: // 请求文件
        if(lcfd.pc->conf.www_folder == NULL) // 如果没有配置www文件夹
            send_error(lcfd.fd, 501, "no www-folder configured"); // 发送错误信息
        else
            send_file(lcfd.pc->id, lcfd.fd, req.parameter); // 发送文件
        break;
    default: // 未知请求
        DBG("unknown request
"); // 输出调试信息
    }

    close(lcfd.fd); // 关闭文件描述符
    free_request(&req); // 释放请求内存

    DBG("leaving HTTP client thread
"); // 输出调试信息
    return NULL;
}

函数_read用于从文件描述符中读取数据，并将读取的数据存储到缓冲区中。下面是函数的主要步骤：初始化变量和数据结构。循环读取数据，直到满足读取长度的要求。使用select函数等待数据到达或超时。调用read函数从文件描述符中读取数据。将读取的数据存储到缓冲区中，并更新相关计数器。如果读取的字节数小于缓冲区大小，将数据移动到缓冲区末尾。返回已读取的字节数。函数_readline是基于_read函数的封装，用于从文件描述符中读取一行数据，直到遇到换行符或达到最大长度。它调用_read函数逐个读取字符，并将字符存储到指定的缓冲区中，直到满足结束条件。返回读取的字符数或-这两个函数可能是某个网络或文件处理程序中的一部分，用于读取和处理输入数据。它们在循环读取和处理数据时提供了超时机制，以防止程序永久阻塞。

int _read(int fd, iobuffer *iobuf, void *buffer, size_t len, int timeout)
{
    int copied = 0, rc, i;
    fd_set fds;
    struct timeval tv;

    memset(buffer, 0, len); // 将buffer清零

    while((copied < len)) { // 循环读取数据
        i = MIN(iobuf->level, len - copied); // 计算需要读取的字节数
        memcpy(buffer + copied, iobuf->buffer + IO_BUFFER - iobuf->level, i); // 将读取到的数据存入buffer中

        iobuf->level -= i; // 更新iobuf中的level
        copied += i; // 更新已读取的字节数
        if(copied >= len) // 如果已读取的字节数等于需要读取的字节数，返回已读取的字节数
            return copied;

        /* select将在超时或有新数据到达时返回 */
        tv.tv_sec = timeout;
        tv.tv_usec = 0;
        FD_ZERO(&fds);
        FD_SET(fd, &fds);
        if((rc = select(fd + 1, &fds, NULL, NULL, &tv)) <= 0) { // 调用select函数等待数据到达或超时
            if(rc < 0) // 如果返回值小于0，说明出错
                exit(EXIT_FAILURE);

            /* 这里一定是超时 */
            return copied; // 返回已读取的字节数
        }

        init_iobuffer(iobuf); // 初始化iobuf

        /*
         * 由于select函数已经返回，所以这里应该至少有一个字节可读
         * 但是，由于在select和read之间，远程socket可能会关闭，所以不能保证一定有数据可读
         */
        if((iobuf->level = read(fd, &iobuf->buffer, IO_BUFFER)) <= 0) { // 调用read函数读取数据
            /* 出错了 */
            return -1; // 返回-1
        }

        /* 如果读取的字节数小于IO_BUFFER，将数据移动到缓冲区末尾 */
        memmove(iobuf->buffer + (IO_BUFFER - iobuf->level), iobuf->buffer, iobuf->level);
    }

    return 0;
}


/******************************************************************************
Description.: Read a single line from the provided fildescriptor.
              This funtion will return under two conditions:
              * line end was reached
              * timeout occured
Input Value.: * fd.....: fildescriptor to read from
              * iobuf..: iobuffer that allows to use this functions from multiple
                         threads because the complete context is the iobuffer.
              * buffer.: The buffer to store values at, will be set to zero
                         before storing values.
              * len....: the length of buffer
              * timeout: seconds to wait for an answer
Return Value: * buffer.: will become filled with bytes read
              * iobuf..: May get altered to save the context for future calls.
              * func().: bytes copied to buffer or -1 in case of error
******************************************************************************/
/* read just a single line or timeout */
int _readline(int fd, iobuffer *iobuf, void *buffer, size_t len, int timeout)
{
    char c = "", *out = buffer; // 定义字符变量c和指向buffer的指针out
    int i;

    memset(buffer, 0, len); // 将buffer清零

    for(i = 0; i < len && c != "
"; i++) { // 循环读取每个字符，直到读取到换行符或达到最大长度
        if(_read(fd, iobuf, &c, 1, timeout) <= 0) { // 调用_read函数读取一个字符，如果返回值小于等于0，说明超时或出错
            /* timeout or error occured */ // 超时或出错
            return -1; // 返回-1
        }
        *out++ = c; // 将读取到的字符存入buffer中
    }

    return i; // 返回读
                        文章为作者独立观点，不代表 股票程序化软件自动交易接口观点