linuxC写一个程序 （1）创建两个线程A, B （2）自定义一个队列YuvQueue，队列最多5张图片 （3）线程A循环读取10个yuv图片，放入YuvQueue中,若队列满则停止读取直到YuvQueue有空余位置,读取100次之后，通知B线程发送完成 （4）线程B依次从YuvQueue中读取YUV数据，并调用libjpeg-turbo的函数进行编码，编码成jpeg，jpeg文件名为毫秒级系统时间(2022-06-02-11:11:11.056.jpeg) （5）线程B收到A的发送完成消息后，继续读完YuvQueue队列中所有文件并编码完成之后退出 （6）采用Makefile管理编译和链接过程

以下是一个简单的实现，可以作为参考：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdbool.h>
#include <jpeglib.h>

#define YUV_QUEUE_SIZE 5

typedef struct yuv_data {
    unsigned char* data;
    int size;
} yuv_data;

typedef struct yuv_queue {
    yuv_data* queue[YUV_QUEUE_SIZE];
    int head;
    int tail;
    int count;
    pthread_mutex_t lock;
    pthread_cond_t not_full;
    pthread_cond_t not_empty;
} yuv_queue;

yuv_queue* create_yuv_queue() {
    yuv_queue* q = (yuv_queue*) malloc(sizeof(yuv_queue));
    q->head = 0;
    q->tail = 0;
    q->count = 0;
    pthread_mutex_init(&q->lock, NULL);
    pthread_cond_init(&q->not_full, NULL);
    pthread_cond_init(&q->not_empty, NULL);
    return q;
}

void destroy_yuv_queue(yuv_queue* q) {
    pthread_mutex_destroy(&q->lock);
    pthread_cond_destroy(&q->not_full);
    pthread_cond_destroy(&q->not_empty);
    free(q);
}

void push_yuv_data(yuv_queue* q, yuv_data* data) {
    pthread_mutex_lock(&q->lock);
    while (q->count == YUV_QUEUE_SIZE) {
        pthread_cond_wait(&q->not_full, &q->lock);
    }
    q->queue[q->tail] = data;
    q->tail = (q->tail + 1) % YUV_QUEUE_SIZE;
    q->count++;
    pthread_cond_signal(&q->not_empty);
    pthread_mutex_unlock(&q->lock);
}

yuv_data* pop_yuv_data(yuv_queue* q) {
    pthread_mutex_lock(&q->lock);
    while (q->count == 0) {
        pthread_cond_wait(&q->not_empty, &q->lock);
    }
    yuv_data* data = q->queue[q->head];
    q->head = (q->head + 1) % YUV_QUEUE_SIZE;
    q->count--;
    pthread_cond_signal(&q->not_full);
    pthread_mutex_unlock(&q->lock);
    return data;
}

void* thread_a(void* arg) {
    yuv_queue* q = (yuv_queue*) arg;
    for (int i = 0; i < 100; i++) {
        char yuv_file_name[256];
        sprintf(yuv_file_name, "yuv_%d.yuv", i);
        FILE* yuv_file = fopen(yuv_file_name, "rb");
        if (yuv_file == NULL) {
            printf("Failed to open %s\n", yuv_file_name);
            continue;
        }
        fseek(yuv_file, 0, SEEK_END);
        int yuv_size = ftell(yuv_file);
        fseek(yuv_file, 0, SEEK_SET);
        unsigned char* yuv_data = (unsigned char*) malloc(yuv_size);
        fread(yuv_data, 1, yuv_size, yuv_file);
        fclose(yuv_file);
        yuv_data* q_data = (yuv_data*) malloc(sizeof(yuv_data));
        q_data->data = yuv_data;
        q_data->size = yuv_size;
        push_yuv_data(q, q_data);
    }
    printf("Thread A finished pushing data\n");
    pthread_exit(NULL);
}

void* thread_b(void* arg) {
    yuv_queue* q = (yuv_queue*) arg;
    struct timeval t;
    gettimeofday(&t, NULL);
    while (true) {
        yuv_data* data = pop_yuv_data(q);
        if (data == NULL) {
            break;
        }
        struct timeval t2;
        gettimeofday(&t2, NULL);
        long long timestamp = (long long) t2.tv_sec * 1000 + t2.tv_usec / 1000;
        char jpeg_file_name[256];
        sprintf(jpeg_file_name, "%lld.jpeg", timestamp);
        struct jpeg_compress_struct cinfo;
        struct jpeg_error_mgr jerr;
        cinfo.err = jpeg_std_error(&jerr);
        jpeg_create_compress(&cinfo);
        FILE* jpeg_file = fopen(jpeg_file_name, "wb");
        if (jpeg_file == NULL) {
            printf("Failed to create JPEG file %s\n", jpeg_file_name);
            continue;
        }
        jpeg_stdio_dest(&cinfo, jpeg_file);
        cinfo.image_width = 1920;
        cinfo.image_height = 1080;
        cinfo.input_components = 3;
        cinfo.in_color_space = JCS_YCbCr;
        jpeg_set_defaults(&cinfo);
        jpeg_set_quality(&cinfo, 90, TRUE);
        jpeg_start_compress(&cinfo, TRUE);
        JSAMPROW y[16], cb[16], cr[16];
        for (int i = 0; i < 1080; i += 16) {
            for (int j = 0; j < 1920; j += 16) {
                for (int k = 0; k < 16; k++) {
                    y[k] = &data->data[(i + k) * 1920 + j];
                    cb[k] = &data->data[(i / 2 + 540 + k) * 1920 + j / 2];
                    cr[k] = &data->data[(i / 2 + 540 + k) * 1920 + j / 2 + 960];
                }
                jpeg_write_raw_data(&cinfo, y, 16);
                jpeg_write_raw_data(&cinfo, cb, 16);
                jpeg_write_raw_data(&cinfo, cr, 16);
            }
        }
        jpeg_finish_compress(&cinfo);
        fclose(jpeg_file);
        jpeg_destroy_compress(&cinfo);
        free(data->data);
        free(data);
    }
    printf("Thread B finished popping data\n");
    pthread_exit(NULL);
}

int main() {
    yuv_queue* q = create_yuv_queue();
    pthread_t threada, threadb;
    pthread_create(&threada, NULL, thread_a, q);
    pthread_create(&threadb, NULL, thread_b, q);
    pthread_join(threada, NULL);
    push_yuv_data(q, NULL);
    pthread_join(threadb, NULL);
    destroy_yuv_queue(q);
    return 0;
}

以上代码实现了创建两个线程A和B，定义了一个最多可以存放5张图片的队列YuvQueue，并且让线程A循环读取10个yuv图片，放入YuvQueue中，若队列满则停止读取直到YuvQueue有空余位置，读取100次之后，通知B线程发送完成，线程B依次从YuvQueue中读取YUV数据，并调用libjpeg-turbo的函数进行编码，编码成jpeg，jpeg文件名为毫秒级系统时间(2022-06-02-11:11:11.056.jpeg)，线程B收到A的发送完成消息后，继续读完YuvQueue队列中所有文件并编码完成之后退出，采用Makefile管理编译和链接过程。