FFmpeg 入门(4)：线程分治

本文转自：FFmpeg 入门(4)：线程分治 | www.samirchen.com

概览

上一节教程中，我们使用 SDL 的音频相关的函数来支持音频播放。SDL 起了一个线程来在需要音频数据的时候去调用我们定义的回调方法。现在我们要做的是用线程的方法去改造视频显示这块的逻辑。这样一来会使得代码的机构更模块化，这样改动起来会更简单，尤其是当我们想添加音视频同步逻辑时。

我们从哪开始呢？首先，我们发现我们的 main 函数做的事情太多了：运行 event loop、读取数据包、进行视频解码等等，所以我们现在要做的就是把这些事情拆分掉：一个线程来专门做数据包解码，这些数据包会被添加到队列中，并分别被音频处理线程和视频处理线程来读取和处理。音频处理线程我们在上一节已经按照设想写好了，视频处理线程要复杂一些，因为我们需要自己来显示视频。我们要把显示视频的代码放到 main loop，但是不会每次循环的时候去做显示，而是把视频显示集成 event loop 中去。方式就是解码视频数据，把视频帧存到另一个队列，然后创建一个自定义事件(FF_REFRESH_EVENT)添加到事件系统，然后当 event loop 处理这个事件时就会显示队列中的下一帧。下面我们用个图来说明下这个流程：

 ________ audio  _______      _____
|        | pkts |       |    |     | to speaker.
| DECODE |----->| AUDIO |--->| SDL |-->
|________|      |_______|    |_____|
    |  video     _______
    |   pkts    |       |
    +---------->| VIDEO |
 ________       |_______|   _______
|       |          |       |       |
| EVENT |          +------>| VIDEO | to monitor.
| LOOP  |----------------->| DISP. |-->
|_______|<---FF_REFRESH----|_______|

把视频显示的逻辑放到 event loop 中去的主要目的是为了使用 SDL_Delay 线程，这样我们可以准确的控制下一个视频帧什么时候显示到屏幕上。在下一节教程中当我们要做音视频同步时，相关的逻辑就会变得简单些了。

精简代码

我们现在要创建一个比较大的结构体来容纳所有音视频信息，叫做 VideoState。

typedef struct VideoState {
    AVFormatContext *pFormatCtx;
    int videoStream, audioStream;
    AVStream *audio_st;
    PacketQueue audioq;
    uint8_t audio_buf[(MAX_AUDIO_FRAME_SIZE * 3) / 2];
    unsigned int audio_buf_size;
    unsigned int audio_buf_index;
    AVFrame audio_frame;
    AVPacket audio_pkt;
    uint8_t *audio_pkt_data;
    int audio_pkt_size;
    AVStream *video_st;
    PacketQueue videoq;
    
    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
    int pictq_size, pictq_rindex, pictq_windex;
    SDL_mutex *pictq_mutex;
    SDL_cond *pictq_cond;
    
    SDL_Thread *parse_tid;
    SDL_Thread *video_tid;
    
    char filename[1024];
    int quit;
    
    AVIOContext *io_context;
    struct SwsContext *sws_ctx;
} VideoState;

简单看看 VideoState 中都有什么。首先，格式信息 pFormatCtx；视频和音频流的标记 videoStream、audioStream，以及对应的视频和音频流对象 audio_st、video_st；接下来，是我们移过来的音频缓冲区相关的数据：audio_buf、audio_buf_size、audio_buf_index 等；我们还添加了视频数据队列 videoq、视频数据缓冲区 pictq 来存储解码后的视频帧，VideoPicture 是我们自己创建的数据结构，我们后面再看里面都有些啥；我们还增加了两个指向对应线程的指针：parse_tid、video_tid；此外还有退出标志 quit，媒体文件名 filename 等等。

现在我们回到 main 函数来看看我们的程序都有哪些改变。首先，我们创建 VideoState 并分配内存：

int main(int argc, char *argv[]) {
    SDL_Event event;
    VideoState *is;
    is = av_mallocz(sizeof(VideoState));
    // ... code ...
}

av_mallocz() 会为我们分配内存并将内存初始化为 0。

接着，初始化视频渲染相关数据缓冲区 pictq 的锁。因为事件循环调用我们的渲染函数时，渲染逻辑就会从 pictq 获取数据，同时解码逻辑又会往 pictq 写入数据，我们不知道谁会先到，所以这里需要通过锁机制来防止线程错乱。同时，我们这里把媒体文件路径也拷贝到 VideoState 中。

av_strlcpy(is->filename, argv[1], sizeof(is->filename));

is->pictq_mutex = SDL_CreateMutex();
is->pictq_cond = SDL_CreateCond();

av_strlcpy 是 FFmpeg 基于 strncpy 提供的一个字符串拷贝方法，增加了一些边界检查功能。

第一个线程

现在我们启动 decode_thread() 线程来开始工作：

schedule_refresh(is, 40);
    
is->parse_tid = SDL_CreateThread(decode_thread, is);
if (!is->parse_tid) {
    av_free(is);
    return -1;
}

我们将在后面实现 schedule_refresh() 函数，它的主要功能就是告诉系统在指定的延时后来推送一个 FF_REFRESH_EVENT 事件。这个事件将在事件队列里触发 video refresh 函数的调用。不过，现在我们还是先来看看 SDL_CreateThread() 函数。

SDL_CreateThread() 函数会分发一个新的线程，这个线程有原进程的所有内存的访问权限，并从我们指定的函数开始运行。这个线程会给指定的函数传入一个用户定义的数据作为参数，在我们这里，我们调用的函数是 decode_thread() 传入的参数是前面初始化的 VideoState。decode_thread() 的前半部分没有什么新鲜的：打开媒体文件找到视频流和音频流的索引。这里与之前唯一的不同就是 AVFormatContext 被我们放到 VideoState 中去了。在找到了视频流和音频流后，我们接下来就调用另一个我们将实现的函数: stream_component_open()。这里我们就将代码模块化了，对重复的工作完成了一些代码复用。

stream_component_open() 函数主要用于帮我们找到对应的解码器、创建对应的音频配置、保存关键信息到 VideoState、启动音频和视频线程。这个函数也是我们添加其他配置的地方，比如强制使用给定的 codec 而不是自动检测等等。代码如下：

int stream_component_open(VideoState *is, int stream_index) {
    
    AVFormatContext *pFormatCtx = is->pFormatCtx;
    AVCodecContext *codecCtx = NULL;
    AVCodec *codec = NULL;
    AVDictionary *optionsDict = NULL;
    SDL_AudioSpec wanted_spec, spec;
    
    if (stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
        return -1;
    }
    
    // Get a pointer to the codec context for the video stream.
    codecCtx = pFormatCtx->streams[stream_index]->codec;
    
    if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {
        // Set audio settings from codec info.
        wanted_spec.freq = codecCtx->sample_rate;
        wanted_spec.format = AUDIO_S16SYS;
        wanted_spec.channels = codecCtx->channels;
        wanted_spec.silence = 0;
        wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
        wanted_spec.callback = audio_callback;
        wanted_spec.userdata = is;
        
        if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
            fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
            return -1;
        }
    }
    codec = avcodec_find_decoder(codecCtx->codec_id);
    if (!codec || (avcodec_open2(codecCtx, codec, &optionsDict) < 0)) {
        fprintf(stderr, "Unsupported codec!\n");
        return -1;
    }
    
    switch(codecCtx->codec_type) {
        case AVMEDIA_TYPE_AUDIO:
            is->audioStream = stream_index;
            is->audio_st = pFormatCtx->streams[stream_index];
            is->audio_buf_size = 0;
            is->audio_buf_index = 0;
            memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
            packet_queue_init(&is->audioq);
            SDL_PauseAudio(0);
            break;
        case AVMEDIA_TYPE_VIDEO:
            is->videoStream = stream_index;
            is->video_st = pFormatCtx->streams[stream_index];
            
            packet_queue_init(&is->videoq);
            is->video_tid = SDL_CreateThread(video_thread, is);
            is->sws_ctx = sws_getContext(is->video_st->codec->width, is->video_st->codec->height, is->video_st->codec->pix_fmt, is->video_st->codec->width, is->video_st->codec->height, AV_PIX_FMT_YUV420P, SWS_BILINEAR, NULL, NULL, NULL);
            break;
        default:
            break;
    }
    return 0;
}

上面的函数主要是服务于音频和视频，这里把 VideoState 作为回调函数的参数数据。同时，我们保存了 audio_st 和 video_st，还初始化了视频队列 videoq 和音频队列 audioq。最重要的是，我们在这里启动了音频线程和视频线程。

SDL_PauseAudio(0);
break;

// ...... 

is->video_tid = SDL_CreateThread(video_thread, is);

我们接着看看 decode_thread() 的后半部分，这部分的主要工作是通过一个循环来读取 packet 并把它放入正确的队列：

int decode_thread(void *arg) {

    // ... code ...

    // Main decode loop.
    for (;;) {
        if (is->quit) {
            break;
        }
        // Seek stuff goes here.
        if (is->audioq.size > MAX_AUDIOQ_SIZE || is->videoq.size > MAX_VIDEOQ_SIZE) {
            SDL_Delay(10);
            continue;
        }
        if (av_read_frame(is->pFormatCtx, packet) < 0) {
            if (is->pFormatCtx->pb->error == 0) {
                SDL_Delay(100); // No error; wait for user input.
                continue;
            } else {
                break;
            }
        }
        // Is this a packet from the video stream?
        if (packet->stream_index == is->videoStream) {
            packet_queue_put(&is->videoq, packet);
        } else if (packet->stream_index == is->audioStream) {
            packet_queue_put(&is->audioq, packet);
        } else {
            av_packet_unref(packet);
        }
    }

    // All done - wait for it.
    while (!is->quit) {
        SDL_Delay(100);
    }

    fail:
    if (1) {
        SDL_Event event;
        event.type = FF_QUIT_EVENT;
        event.user.data1 = is;
        SDL_PushEvent(&event);
    }
    return 0;
}

上面代码的 for 循环中，我们为音频队列和视频队列添加了 max size，还增加了对读数据错误的检查。AVFormatContext *pFormatCtx 有一个 ByteIOContext 成员，这个成员会记录所有底层文件信息。

在循环完成后，接下来的逻辑就是等待其他任务结束，以及发出通知告诉其他任务我们这已经结束了。这段扫尾代码也演示了如何发事件。

我们通过 SDL 提供的常量 SDL_USEREVENT 来取得用户事件，第一个用户事件的值为 SDL_USEREVENT，往后则都是累加 1。比如，FF_QUIT_EVENT 事件在我们的程序中的值是 SDL_USEREVENT + 1。我们还可以给事件附加上用户数据，我们的程序中，我们把用户数据的指针指向了 is。最后我们调用 SDL_PushEvent() 函数将事件发布出去。在后续的事件处理逻辑中，我们将遍历和处理事件。现在要明确的就是我们这里发出了 FF_QUIT_EVENT 事件，我们将获取这个事件并将 quit 标志置为 1。

获取帧：video_thread

在 codec 准备好后，我们启动 video thread。这个线程从 video queue 中读取数据包 packet，解码为视频帧，然后调用 queue_picture() 函数将处理好的帧添加到 picture queue。

int video_thread(void *arg) {
    VideoState *is = (VideoState *) arg;
    AVPacket pkt1, *packet = &pkt1;
    int frameFinished;
    AVFrame *pFrame;
    
    pFrame = av_frame_alloc();
    
    for (;;) {
        if (packet_queue_get(&is->videoq, packet, 1) < 0) {
            // Means we quit getting packets.
            break;
        }
        // Decode video frame.
        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished, packet);
        
        // Did we get a video frame?
        if (frameFinished) {
            if (queue_picture(is, pFrame) < 0) {
                break;
            }
        }
        av_packet_unref(packet);
    }
    av_free(pFrame);
    return 0;
}

这里的代码还是比较清晰的，我们把 avcodec_decode_video2() 函数挪到了这里，由于很多信息被我们放到了 VideoState 中，所以这里的参数我们做了改变，比如：我们通过 is->video_st->codec 从 VideoState 中获取视频的 codec。我们持续从 video queue 中获取 packet 数据包，直到有人告诉我们 quit 或者遇到错误。

帧队列

接着，我们看一下存储解码帧的函数 queue_picture()，由于我们的 picture queue 里放的是 SDL overlay，所以我们需要把视频帧转换为 SDL overlay。

typedef struct VideoPicture {
    SDL_Overlay *bmp;
    int width, height; // Source height & width..
    int allocated;
} VideoPicture;

VideoState 中有个缓冲区用来存储 VideoPicture，但是我们需要自己创建和分配 SDL_Overlay 的内存，注意，allocated 就是用来标记我们有没有做这件事。

我们需要两个指针来帮助我们使用这个队列：写索引和读索引。我们同时也记录缓冲区有多少图像。当要往队列写入数据时，我们首先要等缓冲区清理出空间来存放 VideoPicture。然后我们检查我们是否在写索引位置创建了 SDL overlay，如果没有则需要分配对应的内存。如果窗口的尺寸发生改变了，我们还要重新创建缓冲区。

int queue_picture(VideoState *is, AVFrame *pFrame) {
    
    VideoPicture *vp;
    AVFrame pict;
    
    // Wait until we have space for a new pic.
    SDL_LockMutex(is->pictq_mutex);
    while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->quit) {
        SDL_CondWait(is->pictq_cond, is->pictq_mutex);
    }
    SDL_UnlockMutex(is->pictq_mutex);
    
    if (is->quit) {
        return -1;
    }
    
    // windex is set to 0 initially.
    vp = &is->pictq[is->pictq_windex];
    
    // Allocate or resize the buffer!
    if (!vp->bmp || vp->width != is->video_st->codec->width || vp->height != is->video_st->codec->height) {
        SDL_Event event;
        
        vp->allocated = 0;
        // We have to do it in the main thread.
        event.type = FF_ALLOC_EVENT;
        event.user.data1 = is;
        SDL_PushEvent(&event);
        
        // Wait until we have a picture allocated.
        SDL_LockMutex(is->pictq_mutex);
        while (!vp->allocated && !is->quit) {
            SDL_CondWait(is->pictq_cond, is->pictq_mutex);
        }
        SDL_UnlockMutex(is->pictq_mutex);
        if (is->quit) {
            return -1;
        }
    }
    
    // ... code ...

}

这里我们发送了一个事件 FF_ALLOC_EVENT，处理这个事件的代码在主线程中：

case FF_ALLOC_EVENT:
    alloc_picture(event.user.data1);
    break;

这里调用了 alloc_picture() 函数，我们来看一下这个函数：

void alloc_picture(void *userdata) {
    
    VideoState *is = (VideoState *)userdata;
    VideoPicture *vp;
    
    vp = &is->pictq[is->pictq_windex];
    if (vp->bmp) {
        // We already have one make another, bigger/smaller.
        SDL_FreeYUVOverlay(vp->bmp);
    }
    // Allocate a place to put our YUV image on that screen.
    SDL_LockMutex(screen_mutex);
    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width, is->video_st->codec->height, SDL_YV12_OVERLAY, screen);
    SDL_UnlockMutex(screen_mutex);
    vp->width = is->video_st->codec->width;
    vp->height = is->video_st->codec->height;
    
    SDL_LockMutex(is->pictq_mutex);
    vp->allocated = 1;
    SDL_CondSignal(is->pictq_cond);
    SDL_UnlockMutex(is->pictq_mutex);
    
}

我们把 SDL_CreateYUVOverlay() 从 main 函数中移到了这里，现在我们对这个函数加了锁，因为有两个线程可以同时往屏幕写数据，这样能防止 alloc_picture() 函数和显示视频的函数发生冲突。需要注意我们在 VideoPicture 中记录了视频的宽度和高度，因为我们需要确保我们的视频尺寸不会发生改变。

现在我们已经创建了 YUV overlay 并分配了内存，我们做好了接收图像的准备。现在我们回到 queue_picture() 函数来看看拷贝视频帧到 YUV overlay 的这部分代码：

int queue_picture(VideoState *is, AVFrame *pFrame) {

    // Allocate a frame if we need it... 
    // ... code ...
    // We have a place to put our picture on the queue 

    // We have a place to put our picture on the queue.
    if (vp->bmp) {
        
        SDL_LockYUVOverlay(vp->bmp);
        
        // Point pict at the queue.
        pict.data[0] = vp->bmp->pixels[0];
        pict.data[1] = vp->bmp->pixels[2];
        pict.data[2] = vp->bmp->pixels[1];
        
        pict.linesize[0] = vp->bmp->pitches[0];
        pict.linesize[1] = vp->bmp->pitches[2];
        pict.linesize[2] = vp->bmp->pitches[1];
        
        // Convert the image into YUV format that SDL uses.
        sws_scale(is->sws_ctx, (uint8_t const * const *)pFrame->data, pFrame->linesize, 0, is->video_st->codec->height, pict.data, pict.linesize);
        
        SDL_UnlockYUVOverlay(vp->bmp);
        // Now we inform our display thread that we have a pic ready.
        if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {
            is->pictq_windex = 0;
        }
        SDL_LockMutex(is->pictq_mutex);
        is->pictq_size++;
        SDL_UnlockMutex(is->pictq_mutex);
    }
    return 0;
}

这段代码主要是用视频帧来填充 YUV overlay 的逻辑。最后一段代码就是向队列添加数据，这个队列工作的方式就是不断地往里添加数据直到队列满掉，然后不断从中读取数据只要里面还有数据，所以读写操作都会依赖 is->pictq_size 的值，所以这里我们要给它加锁。我们在这里做的就是，将写指针递增，然后锁住队列并增加它的 size。然后读数据方会知道队列中有数据了，如果队列满了，我们写数据方也会知道。

显示视频

上面介绍完了 video thread，我们接下来来看看 schedule_refresh()：

// Schedule a video refresh in 'delay' ms.
static void schedule_refresh(VideoState *is, int delay) {
    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
}

SDL_AddTimer() 是一个 SDL 的函数，用来在指定的时间(ms)后回调用户指定的函数，当然还可以选择带上用户指定的数据。我们将用 schedule_refresh 这个函数来做图像更新：每次我们调用这个函数，它就会设置一个定时器，这个定时器会触发一个事件来让 main 函数的事件处理逻辑去从 picture queue 取得一帧数据来显示出来。

static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {
    SDL_Event event;
    event.type = FF_REFRESH_EVENT;
    event.user.data1 = opaque;
    SDL_PushEvent(&event);
    return 0; // 0 means stop timer.
}

sdl_refresh_timer_cb() 就是定时器会触发调用的那个用于发事件的函数，FF_REFRESH_EVENT 事件被定义为了 SDL_USEREVENT + 1。主要注意的是当我们在这里返回 0 时，SDL 会停止这个定时器，这样也就停止去调用这个回调了。

既然我们这里发出了 FF_REFRESH_EVENT 事件，那么就需要有地方处理它，这个地方就在 main 函数的 event loop 中：

for (;;) {
    
    SDL_WaitEvent(&event);
    switch(event.type) {

        // ... code ...
        
        case FF_REFRESH_EVENT:
            video_refresh_timer(event.user.data1);
            break;

        // ... code ...

    }
}

从这里可以看到，处理这个事件的函数是 video_refresh_timer()：

void video_refresh_timer(void *userdata) {
    
    VideoState *is = (VideoState *)userdata;
    // vp is used in later tutorials for synchronization.
    VideoPicture *vp;
    
    if (is->video_st) {
        if (is->pictq_size == 0) {
            schedule_refresh(is, 1);
        } else {
            vp = &is->pictq[is->pictq_rindex];

            // Now, normally here goes a ton of code about timing, etc. we're just going to guess at a delay for now. You can increase and decrease this value and hard code the timing - but I don't suggest that, We'll learn how to do it for real later.
            schedule_refresh(is, 80);
            
            // Show the picture!
            video_display(is);
            
            // Update queue for next picture!
            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {
                is->pictq_rindex = 0;
            }
            SDL_LockMutex(is->pictq_mutex);
            is->pictq_size--;
            SDL_CondSignal(is->pictq_cond);
            SDL_UnlockMutex(is->pictq_mutex);
        }
    } else {
        schedule_refresh(is, 100);
    }
}

这是一个比较简单的函数：当 pictq 队列有数据时就取出 VideoPicture，设置显示下一帧图像的 timer，调用 video_display() 来将视频显示出来，增加队列的计数器，更新队列的 size。你可能注意到了，这里我们虽然取出了一个 VideoPicture 但并没有使用它，原因是我们后面会用到。后面我们会用这个 VideoPicture 的时间信息来做音视频同步相关的工作，其中的时间信息将告诉我们该何时显示下一帧图像，我们会把这个时间信息传给 schedule_refresh()。而现在，我们只是简单的传了一个 80。

现在我们要做的最后一件事就是 video_display() 函数：

void video_display(VideoState *is) {
    SDL_Rect rect;
    VideoPicture *vp;
    float aspect_ratio;
    int w, h, x, y;
    
    vp = &is->pictq[is->pictq_rindex];
    if (vp->bmp) {
        if (is->video_st->codec->sample_aspect_ratio.num == 0) {
            aspect_ratio = 0;
        } else {
            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio) * is->video_st->codec->width / is->video_st->codec->height;
        }
        if (aspect_ratio <= 0.0) {
            aspect_ratio = (float) is->video_st->codec->width / (float) is->video_st->codec->height;
        }
        h = screen->h;
        w = ((int)rint(h * aspect_ratio)) & -3;
        if (w > screen->w) {
            w = screen->w;
            h = ((int)rint(w / aspect_ratio)) & -3;
        }
        x = (screen->w - w) / 2;
        y = (screen->h - h) / 2;
        
        rect.x = x;
        rect.y = y;
        rect.w = w;
        rect.h = h;
        SDL_LockMutex(screen_mutex);
        SDL_DisplayYUVOverlay(vp->bmp, &rect);
        SDL_UnlockMutex(screen_mutex);
    }
}

由于我们的屏幕可以是任意尺寸（我们自己设置的是 640x480，但是这个对用户应该是可以改变的），所以我们需要能够动态地计算我们要显示图像的尺寸。首先，我们需要计算出视频的 aspect ratio，即宽度和高度的比例(width/height)。但是有一些 codec 有很奇怪的 sample aspect ration，即单像素(单采样)的宽高比(width/height)，又由于我们的 AVCodecContext 中的宽度和高度是以像素为单位来表示的，那么这时候 actual aspect ratio 应该是 aspect ratio 乘上 sample aspect ratio。有的 codec 的 aspect ratio 值是 0，这表示的是每个像素的尺寸是 1x1。

接下来，我们放大视频来尽量适配我们的屏幕。代码中的 & -3 位操作可以将数值调整到最接近 4 的倍数，然后我们将视频居中，并调用 SDL_DisplayYUVOverlay()，这里要确保我们通过 screen_mutex 来加锁。

到这里，我们还需要用新的 VideoState 来重写音频处理的代码，但这里的工作还是比较少的，参见样例代码。最后我们要修改一下 FFmpeg 的内部退出回调对应的函数：

// Since we only have one decoding thread, the Big Struct can be global in case we need it.
VideoState *global_video_state;

int decode_interrupt_cb(void *opaque) {
    return (global_video_state && global_video_state->quit);
}

我们在主函数设置 global_video_state 为 VideoState *is。

以上便是我们这节教程的全部内容，其中的完整代码你可以从这里获得：https://github.com/samirchen/TestFFmpeg

编译执行

你可以使用下面的命令编译它：

$ gcc -o tutorial04 tutorial04.c -lavutil -lavformat -lavcodec -lswscale -lz -lm `sdl-config --cflags --libs`

找一个视频文件，你可以这样执行一下试试：

$ tutorial04 myvideofile.mp4