FFmpeg学习之七（视音频流缓存）

最新推荐文章于 2024-07-21 00:38:10 发布
最新推荐文章于 2024-07-21 00:38:10 发布
阅读量3.5k 收藏 12
点赞数 2
分类专栏： FFmpeg 文章标签： 视音频流缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kyl282889543/article/details/97885873
版权

FFmpeg学习之七（视音频流缓存）

缓存队列实现

源码下载

  1. 视频音频缓存队列实现源码demo

1.原理

初始化固定数量的结点装入空闲队列，当相机回调产生数据后，从空闲队列头部取出一个结点将产生的每一帧图像buffer装入，然后入队到工作队列的尾部，处理buffer的线程从工作队列的头部取出一个结点中的Buffer进行处理，处理完成后会将装有次buffer的结点中data置空并重新放入空闲队列的头部以供下次使用。

我们将空闲队列设计为头进头出，影响不大，因为我们每次只需要从空闲队列中取出一个空结点以供我们装入相机数据，所以没必要按照尾进头出的方式保证结点的顺序。
我们将工作队列设计为尾进头出，因为我们要确保从相机中捕获的数据是连续的，以便后期我们播放出来的画面也是连续的，所以工作队列必须保证尾进头出。
这样做我们相当于实现了用空闲队列当做缓冲队列，在正常情况下(fps=30,即每秒产生30帧数据，大约每33ms产生一帧数据)，如果在33ms内对数据进行的操作可以正常完成，则工作队列会保持始终为0或1，但是如果长期工作或遇到某一帧数据处理较慢的情况(即处理时间大于33ms)则工作队列的长度会增加，而正因为我们使用了这样的队列会保护那一帧处理慢的数据在仍然能够正常处理完。
注意：这种情景仅用于短时间内仅有几帧数据处理较慢，如果比如1s内有20几帧数据都处理很慢则可能导致工作队列太长，则体现不出此队列的优势。

2.实现细节

2.1 结构体定义

  1. 节点
typedef struct KYLCustomQueueNode {
    void    *data;//结点中使用void *类型的data存放我们需要的sampleBuffer,使用index记录当前装入结点的sampleBuffer的索引，
                  //以便我们在取出结点时比较是否是按照顺序取出，结点中还装着同类型下一个结点的元素。
    size_t  size;  // data size 数据大小
    long    index;
    struct  KYLCustomQueueNode *next; //记录下一个节点指针
} KYLCustomQueueNode;

结点中使用void *类型的data存放我们需要的sampleBuffer,使用index记录当前装入结点的sampleBuffer的索引，以便我们在取出结点时比较是否是按照顺序取出，结点中还装着同类型下一个结点的元素。

  1. 队列类型
//队列中即为我们装载的结点数量，因为我们采用的是预先分配固定内存，
//所以工作队列与空闲队列的和始终不变(因为结点中的元素不在工作队列就在空闲队列)
typedef struct KYLCustomQueue {
    int size;
    KYLCustomQueueType type; //队列类型
    KYLCustomQueueNode *front; //队列头
    KYLCustomQueueNode *rear;  //队列尾
} KYLCustomQueue;

队列中即为我们装载的结点数量，因为我们采用的是预先分配固定内存，所以工作队列与空闲队列的和始终不变(因为结点中的元素不在工作队列就在空闲队列)

2.2 类定义

class KYLQueue
{
public:
    KYLCustomQueue *m_free_queue;//空闲队列
    KYLCustomQueue *m_work_queue;//工作队列
    
    KYLQueue();
    ~KYLQueue();
    
    // Queue Operation

    
    /**
     初始化队列

     @param queue 队列指针 KYLCustomQueue
     @param type 队列类型 KYLCustomQueueType
     */
    void InitQueue(KYLCustomQueue *queue,
                   KYLCustomQueueType type);

    
    /**
     入队

     @param queue 队列指针 KYLCustomQueue
     @param node 队列类型 KYLCustomQueueType
     */
    void EnQueue(KYLCustomQueue *queue,
                 KYLCustomQueueNode *node);

    
    /**
     出队

     @param queue 队列指针 KYLCustomQueue
     @return 出队的节点指针 KYLCustomQueueNode
     */
    KYLCustomQueueNode *DeQueue(KYLCustomQueue *queue);

    
    /**
     清空队列

     @param queue 队列指针KYLCustomQueue
     */
    void ClearKYLCustomQueue(KYLCustomQueue *queue);
    
    
    /**
     释放节点

     @param node 节点指针KYLCustomQueueNode
     */
    void FreeNode(KYLCustomQueueNode* node);
    
    
    /**
     重置队列，释放工作队列和空闲队列资源

     @param workQueue 工作队列指针 KYLCustomQueue
     @param freeQueue 空闲队列指针 KYLCustomQueue
     */
    void ResetFreeQueue(KYLCustomQueue *workQueue, KYLCustomQueue *freeQueue);
    
private:

    pthread_mutex_t free_queue_mutex; //互斥锁
    pthread_mutex_t work_queue_mutex;
};

因为涉及到异步操作，所以需要对结点的操作加锁，使用时需要先初始化队列，然后定义了入队，出队，清除队列中元素，释放结点，重置空闲队列等操作。

2.3 初始化队列

#pragma mark - Queue Size   设置队列的长度，不可过长
const int KYLCustomQueueSize = 3;
KYLQueue::KYLQueue(){
    m_free_queue = (KYLCustomQueue *)malloc(sizeof(struct KYLCustomQueue));
    m_work_queue = (KYLCustomQueue *)malloc(sizeof(struct KYLCustomQueue));
    
    InitQueue(m_free_queue, KYLCustomFreeQueue);
    InitQueue(m_work_queue, KYLCustomWorkQueue);
    
    for (int i = 0; i < KYLCustomQueueSize; i++) {
        KYLCustomQueueNode *node = (KYLCustomQueueNode *)malloc(sizeof(struct KYLCustomQueueNode));
        node->data = NULL;
        node->size = 0;
        node->index= 0;
        this->EnQueue(m_free_queue, node);
    }
    
    pthread_mutex_init(&free_queue_mutex, NULL);
    pthread_mutex_init(&work_queue_mutex, NULL);
    
    log4cplus_info(kModuleName, "%s: Init finish !",__func__);
}

假设空闲队列结点总数为3.首先为工作队列与空闲队列分配内存，其次对其分别进行初始化操作，具体过程可参考Demo,然后根据结点总数来为每个结点初始化分配内存，并将分配好内存的结点入队到空闲队列中。

注意：结点的重用，我们仅仅初始化几个固定数量的结点，因为处理数据量较大，没有必要让程序始终做malloc与free，为了优化我们这里的队列相当于一个静态链表，即结点的复用，因为当结点在工作队列中使用完成后会将其中的数据置空并重新入队到空闲队列中，所以结点的总数始终保持不变。

2.4 入队

如上所述，入队操作如果是空闲队列，则使用头进的方式，即始终让入队的结点在队列的头部，具体代码实现即让当前结点的next指向空闲队列的头结点，然后将当前结点变为空闲队列的头结点；如果入队操作是工作队列，则使用尾进的方式，并对结点的index赋值，以便我们在取出结点时可以打印Index是否连续，如果连续则说明入队时始终保持顺序入队。

代码如下：

/**
 入队
 
 @param queue 队列指针 KYLCustomQueue
 @param node 队列类型 KYLCustomQueueType
 */
void KYLQueue::EnQueue(KYLCustomQueue *queue, KYLCustomQueueNode *node) {
    if (queue == NULL) {
        log4cplus_debug(kModuleName, "%s: current queue is NULL",__func__);
        return;
    }
    
    if (node==NULL) {
        log4cplus_debug(kModuleName, "%s: current node is NULL",__func__);
        return;
    }
    
    node->next = NULL;
    
    if (KYLCustomFreeQueue == queue->type) {
        pthread_mutex_lock(&free_queue_mutex);
        
        if (queue->front == NULL) {
            queue->front = node;
            queue->rear  = node;
        }else {
            /*
             // tail in,head out
             freeQueue->rear->next = node;
             freeQueue->rear = node;
             */
            
            // head in,head out
            node->next = queue->front;
            queue->front = node;
        }
        queue->size += 1;
        log4cplus_debug(kModuleName, "%s: free queue size=%d",__func__,queue->size);
        pthread_mutex_unlock(&free_queue_mutex);
    }
    
    if (KYLCustomWorkQueue == queue->type) {
        pthread_mutex_lock(&work_queue_mutex);
        //TODO
        static long nodeIndex = 0;
        node->index=(++nodeIndex);
        if (queue->front == NULL) {
            queue->front = node;
            queue->rear  = node;
        }else {
            queue->rear->next   = node;
            queue->rear         = node;
        }
        queue->size += 1;
        log4cplus_debug(kModuleName, "%s: work queue size=%d",__func__,queue->size);
        pthread_mutex_unlock(&work_queue_mutex);
    }
}

2.5 出队

出队操作无论空闲队列还是工作队列都是从头出，即取出当前队列头结点中的数据。

代码如下：

/**
 出队
 
 @param queue 队列指针 KYLCustomQueue
 @return 出队的节点指针 KYLCustomQueueNode
 */
KYLCustomQueueNode* KYLQueue::DeQueue(KYLCustomQueue *queue) {
    if (queue == NULL) {
        log4cplus_debug(kModuleName, "%s: current queue is NULL",__func__);
        return NULL;
    }
    
    const char *type = queue->type == KYLCustomWorkQueue ? "work queue" : "free queue";
    pthread_mutex_t *queue_mutex = ((queue->type == KYLCustomWorkQueue) ? &work_queue_mutex : &free_queue_mutex);
    KYLCustomQueueNode *element = NULL;
    
    pthread_mutex_lock(queue_mutex);
    element = queue->front;
    if(element == NULL) {
        pthread_mutex_unlock(queue_mutex);
        log4cplus_debug(kModuleName, "%s: The node is NULL",__func__);
        return NULL;
    }
    
    queue->front = queue->front->next;
    queue->size -= 1;
    pthread_mutex_unlock(queue_mutex);
    
    log4cplus_debug(kModuleName, "%s: type=%s size=%d",__func__,type,queue->size);
    return element;
}

注意：该结点为空与该结点中的数据为空不可混为一谈，如果该结点为空则说明没有从队列中取出结点，即空结点没有内存地址，而结点中的数据则为node->data,在本Demo中为相机产生的每一帧sampleBuffer数据。

2.6 重置空闲队列数据

当我们将执行一些中断操作，例如从本View跳转到其他View，或进入后台等操作，我们需要将工作队列中的结点均置空然后重新放回空闲队列，这样可以保证我们最初申请的结点还均有效可用，保证结点不会丢失。

代码如下：

/**
 重置队列，释放工作队列和空闲队列资源
 
 @param workQueue 工作队列指针 KYLCustomQueue
 @param freeQueue 空闲队列指针 KYLCustomQueue
 */
void KYLQueue::ResetFreeQueue(KYLCustomQueue *workQueue, KYLCustomQueue *freeQueue) {
    if (workQueue == NULL) {
        log4cplus_debug(kModuleName, "%s: The WorkQueue is NULL",__func__);
        return;
    }
    
    if (freeQueue == NULL) {
        log4cplus_debug(kModuleName, "%s: The FreeQueue is NULL",__func__);
        return;
    }
    
    int workQueueSize = workQueue->size;
    if (workQueueSize > 0) {
        for (int i = 0; i < workQueueSize; i++) {
            KYLCustomQueueNode *node = DeQueue(workQueue);
            CFRelease(node->data);
            node->data = NULL;
            EnQueue(freeQueue, node);
        }
    }
    log4cplus_info(kModuleName, "%s: ResetFreeQueue : The work queue size is %d, free queue size is %d",__func__,workQueue->size, freeQueue->size);
}

3.完整代码

  1. 头文件
//
//  KYLQueue.h
//  yuvShowKYLDemo
//
//  Created by yulu kong on 2019/7/31.
//  Copyright © 2019 yulu kong. All rights reserved.
//

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN


typedef enum {
    KYLCustomWorkQueue,
    KYLCustomFreeQueue
} KYLCustomQueueType;

typedef struct KYLCustomQueueNode {
    void    *data;//结点中使用void *类型的data存放我们需要的sampleBuffer,使用index记录当前装入结点的sampleBuffer的索引，
                  //以便我们在取出结点时比较是否是按照顺序取出，结点中还装着同类型下一个结点的元素。
    size_t  size;  // data size 数据大小
    long    index;
    struct  KYLCustomQueueNode *next; //记录下一个节点指针
} KYLCustomQueueNode;

//队列中即为我们装载的结点数量，因为我们采用的是预先分配固定内存，
//所以工作队列与空闲队列的和始终不变(因为结点中的元素不在工作队列就在空闲队列)
typedef struct KYLCustomQueue {
    int size;
    KYLCustomQueueType type; //队列类型
    KYLCustomQueueNode *front; //队列头
    KYLCustomQueueNode *rear;  //队列尾
} KYLCustomQueue;

class KYLQueue
{
public:
    KYLCustomQueue *m_free_queue;//空闲队列
    KYLCustomQueue *m_work_queue;//工作队列
    
    KYLQueue();
    ~KYLQueue();
    
    // Queue Operation

    
    /**
     初始化队列

     @param queue 队列指针 KYLCustomQueue
     @param type 队列类型 KYLCustomQueueType
     */
    void InitQueue(KYLCustomQueue *queue,
                   KYLCustomQueueType type);

    
    /**
     入队

     @param queue 队列指针 KYLCustomQueue
     @param node 队列类型 KYLCustomQueueType
     */
    void EnQueue(KYLCustomQueue *queue,
                 KYLCustomQueueNode *node);

    
    /**
     出队

     @param queue 队列指针 KYLCustomQueue
     @return 出队的节点指针 KYLCustomQueueNode
     */
    KYLCustomQueueNode *DeQueue(KYLCustomQueue *queue);

    
    /**
     清空队列

     @param queue 队列指针KYLCustomQueue
     */
    void ClearKYLCustomQueue(KYLCustomQueue *queue);
    
    
    /**
     释放节点

     @param node 节点指针KYLCustomQueueNode
     */
    void FreeNode(KYLCustomQueueNode* node);
    
    
    /**
     重置队列，释放工作队列和空闲队列资源

     @param workQueue 工作队列指针 KYLCustomQueue
     @param freeQueue 空闲队列指针 KYLCustomQueue
     */
    void ResetFreeQueue(KYLCustomQueue *workQueue, KYLCustomQueue *freeQueue);
    
private:

    pthread_mutex_t free_queue_mutex; //互斥锁
    pthread_mutex_t work_queue_mutex;
};


NS_ASSUME_NONNULL_END
  1. 实现文件
//
//  KYLQueue.m
//  yuvShowKYLDemo
//
//  Created by yulu kong on 2019/7/31.
//  Copyright © 2019 yulu kong. All rights reserved.
//

/*******************************************************************************************************************
 
 我们将空闲队列设计为头进头出，影响不大，因为我们每次只需要从空闲队列中取出一个空结点以供我们装入相机数据，所以没必要按照尾进头出的方式保证结点的顺序。
 我们将工作队列设计为尾进头出，因为我们要确保从相机中捕获的数据是连续的，以便后期我们播放出来的画面也是连续的，所以工作队列必须保证尾进头出。
 这样做我们相当于实现了用空闲队列当做缓冲队列，在正常情况
 (fps=30,即每秒产生30帧数据，大约每33ms产生一帧数据)，如果在33ms内对数据进行的操作可以正常完成，则工作队列会保持始终为0或1，
 但是如果长期工作或遇到某一帧数据处理较慢的情况(即处理时间大于33ms)则工作队列的长度会增加，
 而正因为我们使用了这样的队列会保护那一帧处理慢的数据在仍然能够正常处理完。
 这种情景仅用于短时间内仅有几帧数据处理较慢，如果比如1s内有20几帧数据都处理很慢则可能导致工作队列太长，则体现不出此队列的优势。
 ********************************************************************************************************************/


#import "KYLQueue.h"
#import <pthread.h>
#include "log4cplus.h"

#pragma mark - Queue Size   设置队列的长度，不可过长
const int KYLCustomQueueSize = 3;

const static char *kModuleName = "KYLQueueProcess";

#pragma mark - Init

//构造函数
KYLQueue::KYLQueue(){
    m_free_queue = (KYLCustomQueue *)malloc(sizeof(struct KYLCustomQueue));
    m_work_queue = (KYLCustomQueue *)malloc(sizeof(struct KYLCustomQueue));
    
    InitQueue(m_free_queue, KYLCustomFreeQueue);
    InitQueue(m_work_queue, KYLCustomWorkQueue);
    
    for (int i = 0; i < KYLCustomQueueSize; i++) {
        KYLCustomQueueNode *node = (KYLCustomQueueNode *)malloc(sizeof(struct KYLCustomQueueNode));
        node->data = NULL;
        node->size = 0;
        node->index= 0;
        this->EnQueue(m_free_queue, node);
    }
    
    pthread_mutex_init(&free_queue_mutex, NULL);
    pthread_mutex_init(&work_queue_mutex, NULL);
    
    log4cplus_info(kModuleName, "%s: Init finish !",__func__);
}

/**
 初始化队列
 
 @param queue 队列指针 KYLCustomQueue
 @param type 队列类型 KYLCustomQueueType
 */

void KYLQueue::InitQueue(KYLCustomQueue *queue, KYLCustomQueueType type) {
    if (queue != NULL) {
        queue->type  = type;
        queue->size  = 0;
        queue->front = 0;
        queue->rear  = 0;
    }
}

#pragma mark - Main Operation

/**
 入队
 
 @param queue 队列指针 KYLCustomQueue
 @param node 队列类型 KYLCustomQueueType
 */
void KYLQueue::EnQueue(KYLCustomQueue *queue, KYLCustomQueueNode *node) {
    if (queue == NULL) {
        log4cplus_debug(kModuleName, "%s: current queue is NULL",__func__);
        return;
    }
    
    if (node==NULL) {
        log4cplus_debug(kModuleName, "%s: current node is NULL",__func__);
        return;
    }
    
    node->next = NULL;
    
    if (KYLCustomFreeQueue == queue->type) {
        pthread_mutex_lock(&free_queue_mutex);
        
        if (queue->front == NULL) {
            queue->front = node;
            queue->rear  = node;
        }else {
            /*
             // tail in,head out
             freeQueue->rear->next = node;
             freeQueue->rear = node;
             */
            
            // head in,head out
            node->next = queue->front;
            queue->front = node;
        }
        queue->size += 1;
        log4cplus_debug(kModuleName, "%s: free queue size=%d",__func__,queue->size);
        pthread_mutex_unlock(&free_queue_mutex);
    }
    
    if (KYLCustomWorkQueue == queue->type) {
        pthread_mutex_lock(&work_queue_mutex);
        //TODO
        static long nodeIndex = 0;
        node->index=(++nodeIndex);
        if (queue->front == NULL) {
            queue->front = node;
            queue->rear  = node;
        }else {
            queue->rear->next   = node;
            queue->rear         = node;
        }
        queue->size += 1;
        log4cplus_debug(kModuleName, "%s: work queue size=%d",__func__,queue->size);
        pthread_mutex_unlock(&work_queue_mutex);
    }
}

/**
 出队
 
 @param queue 队列指针 KYLCustomQueue
 @return 出队的节点指针 KYLCustomQueueNode
 */
KYLCustomQueueNode* KYLQueue::DeQueue(KYLCustomQueue *queue) {
    if (queue == NULL) {
        log4cplus_debug(kModuleName, "%s: current queue is NULL",__func__);
        return NULL;
    }
    
    const char *type = queue->type == KYLCustomWorkQueue ? "work queue" : "free queue";
    pthread_mutex_t *queue_mutex = ((queue->type == KYLCustomWorkQueue) ? &work_queue_mutex : &free_queue_mutex);
    KYLCustomQueueNode *element = NULL;
    
    pthread_mutex_lock(queue_mutex);
    element = queue->front;
    if(element == NULL) {
        pthread_mutex_unlock(queue_mutex);
        log4cplus_debug(kModuleName, "%s: The node is NULL",__func__);
        return NULL;
    }
    
    queue->front = queue->front->next;
    queue->size -= 1;
    pthread_mutex_unlock(queue_mutex);
    
    log4cplus_debug(kModuleName, "%s: type=%s size=%d",__func__,type,queue->size);
    return element;
}

/**
 重置队列，释放工作队列和空闲队列资源
 
 @param workQueue 工作队列指针 KYLCustomQueue
 @param freeQueue 空闲队列指针 KYLCustomQueue
 */
void KYLQueue::ResetFreeQueue(KYLCustomQueue *workQueue, KYLCustomQueue *freeQueue) {
    if (workQueue == NULL) {
        log4cplus_debug(kModuleName, "%s: The WorkQueue is NULL",__func__);
        return;
    }
    
    if (freeQueue == NULL) {
        log4cplus_debug(kModuleName, "%s: The FreeQueue is NULL",__func__);
        return;
    }
    
    int workQueueSize = workQueue->size;
    if (workQueueSize > 0) {
        for (int i = 0; i < workQueueSize; i++) {
            KYLCustomQueueNode *node = DeQueue(workQueue);
            CFRelease(node->data);
            node->data = NULL;
            EnQueue(freeQueue, node);
        }
    }
    log4cplus_info(kModuleName, "%s: ResetFreeQueue : The work queue size is %d, free queue size is %d",__func__,workQueue->size, freeQueue->size);
}

/**
 清空队列
 
 @param queue 队列指针KYLCustomQueue
 */
void KYLQueue::ClearKYLCustomQueue(KYLCustomQueue *queue) {
    while (queue->size) {
        KYLCustomQueueNode *node = this->DeQueue(queue);
        this->FreeNode(node);
    }
    
    log4cplus_info(kModuleName, "%s: Clear KYLQueue queue",__func__);
}

/**
 释放节点
 
 @param node 节点指针KYLCustomQueueNode
 */
void KYLQueue::FreeNode(KYLCustomQueueNode* node) {
    if(node != NULL){
        free(node->data);
        free(node);
    }
}

4.调用缓存队列实例

  1. 将samplebuffer放入空闲队列
    设置相机代理后，在 - (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection 方法中将samplebuffer装入空闲队列
    代码如下：
#pragma mark ------------------AVCaptureVideoDataOutputSampleBufferDelegate--------------------------------
// Called whenever an AVCaptureVideoDataOutput instance outputs a new video frame. 每产生一帧视频帧时调用一次
- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection {
    //    if(!CMSampleBufferDataIsReady(sampleBuffer)) {
    //        NSLog( @"sample buffer is not ready. Skipping sample" );
    //        return;
    //    }
    
    //     将相机产生的Samplebuffer入队
    [self addBufferToWorkQueueWithSampleBuffer:sampleBuffer];
    
}

- (void)addBufferToWorkQueueWithSampleBuffer:(CMSampleBufferRef)sampleBuffer {
    KYLCustomQueueNode *node = _captureBufferQueue->DeQueue(_captureBufferQueue->m_free_queue);
    if (node == NULL) {
        log4cplus_debug(kModuleName, "Data in , the node is NULL !");
        return;
    }
    CFRetain(sampleBuffer);
    node->data = sampleBuffer;
    _captureBufferQueue->EnQueue(_captureBufferQueue->m_work_queue, node);
    
    log4cplus_debug(kModuleName, "Data in ,  work size = %d, free size = %d !",_captureBufferQueue->m_work_queue->size, _captureBufferQueue->m_free_queue->size);
}

注意：因为相机回调中捕捉的sampleBuffer是有生命周期的所以需要手动CFRetain一下使我们队列中的结点持有它。

  1. 开启一条线程处理队列中的Buffer

使用pthread创建一条线程，每隔10ms取一次数据,我们可以在此对取到的数据进行我们想要的操作，操作完成后再将清空释放sampleBuffer再将其装入空闲队列供我们循环使用。

代码如下：

#pragma mark - 处理Samplebuffer的线程
- (void)handleCacheThread {
    while (true) {
        // 从队列取出在相机回调中放入队列的线程
        KYLCustomQueueNode *node = _captureBufferQueue->DeQueue(_captureBufferQueue->m_work_queue);
        if (node == NULL) {
            log4cplus_debug(kModuleName, "Data node is NULL");
            usleep(10*1000);
            continue;
        }
        
        CMSampleBufferRef sampleBuffer     = (CMSampleBufferRef)node->data;
        // 打印结点的index，如果连续则说明在相机回调中放入的samplebuffer是连续的
        log4cplus_debug(kModuleName, "Test index : %ld",node->index);
        
        /* 可在此处理从队列中拿到的Buffer，用完后记得释放内存并将结点重新放回空闲队列
         * ........
         */
        
        CFRelease(sampleBuffer);
        node->data = NULL;
        _captureBufferQueue->EnQueue(_captureBufferQueue->m_free_queue, node);
    }
}

void * startCropTask(void *param) {
    pthread_setname_np("TVUCropThread");
    KYLTestBufferController *obj = (__bridge_transfer KYLTestBufferController *)param;
    [obj handleCacheThread];
    
    return NULL;
}

循环缓存队列实现

原理

实现细节

完整代码

  • 头文件：
//
//  KYLCircleBuf.h
//  yuvShowKYLDemo
//
//  Created by yulu kong on 2019/7/27.
//  Copyright © 2019 yulu kong. All rights reserved.
//

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

typedef struct tag_AV_VIDEO_BUF_HEAD
{
    unsigned int head; /* Õ∑£¨±ÿ–ε»”⁄0xFF00FF */
    unsigned int timestamp; // ±º‰¥¡£¨»Áπ˚ «¬ºœÒ£¨‘ÚÃÓ¬ºœÒµƒ ±º‰¥¡£¨»Áπ˚ « µ ± ”∆µ£¨‘ÚŒ™0
    unsigned int len;    /*≥§∂»*/
    unsigned int frametype;
}AV_VIDEO_BUF_HEAD;

typedef struct tag_stAVStreamHead
{
    unsigned int nCodecID;     // refer to SEP2P_ENUM_AV_CODECID
    char   nParameter;     // Video: refer to SEP2P_ENUM_VIDEO_FRAME.   Audio:(samplerate << 2) | (databits << 1) | (channel), samplerate refer to SEP2P_ENUM_AUDIO_SAMPLERATE; databits refer to SEP2P_ENUM_AUDIO_DATABITS; channel refer to SEP2P_ENUM_AUDIO_CHANNEL
    char   nLivePlayback;// Video: 0:live video or audio;  1:playback video or audio
    char   reserve1[2];
    unsigned int  nStreamDataLen;    // Stream data size after following struct 'STREAM_HEAD'
    unsigned int  nTimestamp;        // Timestamp of the frame, in milliseconds
    unsigned char  nNumConnected;    // amount that app connected this device for M,X series when nCodecID is AV_CODECID_VIDEO...
    unsigned char  nNumLiveView;    // amount that app is at liveview UI for M,X series when nCodecID is AV_CODECID_VIDEO...
    char   reserve2[2];
    unsigned int  nPlaybackID;        // reserve2[2,5] -> nPlaybackID, modified on 20141201
}AV_STREAM_HEAD;


class KYLCircleBuf
{
public:
    KYLCircleBuf();
    ~KYLCircleBuf();
    
    bool Create(int size);
    void Release();
    int Read(void* buf, int size);
    int  ReadByPeer(void* buf, int size);
    int Write(void* buf, int size);
    int GetStock();
    void Reset();
    bool IsBufCreateSucceed(){return m_bCreateBufSucceed;}
    char * ReadOneFrame(int &len);
    char* ReadOneFrame1(int &len, AV_VIDEO_BUF_HEAD & videobufhead);
    char* ReadOneFrame2(int &len, AV_STREAM_HEAD & videobufhead);
    
private:
    int Read1(void* buf, int size);
    
    
protected:
    char* m_pBuf;
    int m_nSize;
    int m_nStock;
    int m_nReadPos;
    int m_nWritePos;
    
    int  m_nTimeout;
    
    NSCondition *m_Lock;
    
private:
    
    int m_n;
    bool m_bCreateBufSucceed;
    
};



NS_ASSUME_NONNULL_END
  • 实现文件：
//
//  KYLCircleBuf.m
//  yuvShowKYLDemo
//
//  Created by yulu kong on 2019/7/27.
//  Copyright © 2019 yulu kong. All rights reserved.
//

#import "KYLCircleBuf.h"

KYLCircleBuf::KYLCircleBuf()
{
    m_pBuf = NULL;
    m_nSize = 0;
    m_nStock= 0;
    m_nWritePos= 0;
    m_nReadPos = 0;
    m_bCreateBufSucceed = false;
    m_Lock = [[NSCondition alloc] init];
}

KYLCircleBuf::~KYLCircleBuf()
{
    Release();
    
    //[m_Lock release];
    m_Lock = nil;
}

bool KYLCircleBuf::Create(int size)
{
    if (size <= 0)
    {
        m_bCreateBufSucceed = false;
        return false;
    }
    if (m_pBuf != NULL)
    {
        delete[] m_pBuf;
        m_pBuf = NULL;
    }
    m_pBuf = new char[size];
    if(m_pBuf == NULL)
    {
        m_bCreateBufSucceed = false;
        return false;
    }
    m_nSize = size;
    m_nStock = 0;
    m_nWritePos = 0;
    m_nReadPos = 0;
    m_bCreateBufSucceed = true;
    return true;
}

void KYLCircleBuf::Release()
{
    [m_Lock lock];
    
    m_bCreateBufSucceed = false;
    if (m_pBuf == NULL)
    {
        [m_Lock unlock];
        return;
    }
    if(m_pBuf != NULL)
    {
        delete[] m_pBuf;
        m_pBuf = NULL;
    }
    m_nSize = 0;
    m_nStock = 0;
    m_nReadPos = 0;
    m_nWritePos = 0;
    [m_Lock unlock];
}

char* KYLCircleBuf::ReadOneFrame1(int &len, AV_VIDEO_BUF_HEAD & videobufhead)
{
    [m_Lock lock];
    len = 0;
    if(m_nStock == 0)
    {
        [m_Lock unlock];
        return NULL;
    }
    char *pbuf = NULL;
    AV_VIDEO_BUF_HEAD videohead;
    int nRet = Read1((char*)&videohead, sizeof(AV_VIDEO_BUF_HEAD));
    if(nRet == 0)
    {
        [m_Lock unlock];
        return NULL;
    }
    pbuf = new char[videohead.len] ;
    nRet = Read1((char*)pbuf, videohead.len);
    if(nRet == 0)
    {
        delete []pbuf;
        pbuf = NULL;
        [m_Lock unlock];
        return NULL;
    }
    memcpy((char*)&videobufhead, (char*)&videohead, sizeof(AV_VIDEO_BUF_HEAD));
    len = videohead.len;
    [m_Lock unlock];
    return pbuf;
}

char* KYLCircleBuf::ReadOneFrame2(int &len, AV_STREAM_HEAD & streambufhead)
{
    [m_Lock lock];
    len = 0;
    if(m_nStock == 0)
    {
        [m_Lock unlock];
        return NULL;
    }
    char *pbuf = NULL;
    AV_STREAM_HEAD streamhead;
    int nRet = Read1((char*)&streamhead, sizeof(AV_STREAM_HEAD));
    if(nRet == 0)
    {
        [m_Lock unlock];
        return NULL;
    }
    pbuf = new char[streamhead.nStreamDataLen] ;
    nRet = Read1((char*)pbuf, streamhead.nStreamDataLen);
    if(nRet == 0)
    {
        delete []pbuf;
        pbuf = NULL;
        [m_Lock unlock];
        return NULL;
    }
    memcpy((char*)&streambufhead, (char*)&streamhead, sizeof(AV_STREAM_HEAD));
    len = streamhead.nStreamDataLen;
    [m_Lock unlock];
    return pbuf;
    
}

char* KYLCircleBuf::ReadOneFrame(int &len)
{
    [m_Lock lock];
    len = 0;
    if(m_nStock == 0)
    {
        [m_Lock unlock];
        return NULL;
    }
    char *pbuf = NULL;
    AV_VIDEO_BUF_HEAD videohead;
    int nRet = Read1((char*)&videohead, sizeof(AV_VIDEO_BUF_HEAD));
    if(nRet == 0)
    {
        [m_Lock unlock];
        return NULL;
    }
    pbuf = new char[videohead.len] ;
    if(pbuf == NULL)
    {
        [m_Lock unlock];
        return NULL;
    }
    nRet = Read1((char*)pbuf, videohead.len);
    if(nRet == 0)
    {
        delete []pbuf;
        pbuf = NULL;
        [m_Lock unlock];
        return NULL;
    }
    len = videohead.len;
    [m_Lock unlock];
    return pbuf;
    
}

int KYLCircleBuf::Read1(void* buf, int size)
{
    if (m_nStock < size)
    {
        return 0;
    }
    int left = 0;
    int offs = m_nWritePos - m_nReadPos;
    if (offs > 0)
    {
        memcpy(buf, &m_pBuf[m_nReadPos], size);
        m_nReadPos += size;
    }
    else
    {
        offs = m_nSize - m_nReadPos;
        if (offs > size)
        {
            memcpy(buf, &m_pBuf[m_nReadPos], size);
            m_nReadPos += size;
        }
        else
        {
            memcpy(buf, &m_pBuf[m_nReadPos], offs);
            left = size - offs;
            memcpy(&((char*)buf)[offs], m_pBuf, left);
            m_nReadPos = left;
        }
    }
    m_nStock -= size;
    return size;
}


//从缓存中读数据，当缓存数据不够读则读取失败，返回为0
int KYLCircleBuf::Read(void* buf, int size)
{
    //Lock the buffer
    [m_Lock lock];
    if (m_nStock < size)
    {
        [m_Lock unlock];
        return 0;
    }
    int left = 0;
    int offs = m_nWritePos - m_nReadPos;
    if (offs > 0)
    {
        memcpy(buf, &m_pBuf[m_nReadPos], size);
        m_nReadPos += size;
    }
    else
    {
        offs = m_nSize - m_nReadPos;
        if (offs > size)
        {
            memcpy(buf, &m_pBuf[m_nReadPos], size);
            m_nReadPos += size;
        }
        else
        {
            memcpy(buf, &m_pBuf[m_nReadPos], offs);
            left = size - offs;
            memcpy(&((char*)buf)[offs], m_pBuf, left);
            m_nReadPos = left;
        }
    }
    m_nStock -= size;
    [m_Lock unlock];
    return size;
}

int  KYLCircleBuf::ReadByPeer(void* buf, int size)
{
    //Lock the buffer
    [m_Lock lock];
    if(m_nStock < size)
    {
        [m_Lock unlock];
        return 0;
    }
    int left = 0;
    int offs = m_nWritePos - m_nReadPos;
    if(offs > 0)
    {
        memcpy(buf, &m_pBuf[m_nReadPos], size);
    }else{
        offs = m_nSize - m_nReadPos;
        if(offs > size)
        {
            memcpy(buf, &m_pBuf[m_nReadPos], size);
        }else{
            memcpy(buf, &m_pBuf[m_nReadPos], offs);
            left = size - offs;
            memcpy(&((char*)buf)[offs], m_pBuf, left);
            //m_nReadPos = left;
        }
    }
    [m_Lock unlock];
    return size;
}


int KYLCircleBuf::Write(void* buf, int size)
{
    //Lock the buffer
    [m_Lock lock];
    // the buffer is full
    if (m_nStock + size > m_nSize)
    {
        [m_Lock unlock];
        return 0;
    }
    int left = 0;
    int offs = m_nSize - m_nWritePos;
    if (offs > size)
    {
        memcpy(&m_pBuf[m_nWritePos], buf, size);
        m_nWritePos += size;
    }
    else
    {
        memcpy(&m_pBuf[m_nWritePos], buf, offs);
        left = size - offs;
        memcpy(m_pBuf, &((char*)buf)[offs], left);
        m_nWritePos = left;
    }
    
    m_nStock += size;
    [m_Lock unlock];
    return size;
    
}

int KYLCircleBuf::GetStock()
{
    int n;
    [m_Lock lock];
    n =  m_nStock;
    [m_Lock unlock];
    
    return n;
}

void KYLCircleBuf::Reset()
{
    [m_Lock lock];
    m_nReadPos = 0;
    m_nWritePos = 0;
    m_nStock = 0;
    [m_Lock unlock];
}
极客雨露
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FFmpeg+SDL2实现音频流播放
irainsa的博客
11-02 445
SDL2文章列表之前完成了PCM音频的播放，这次实现的是FFmpeg+SDL2播放任意视频中的音频流。整体的流程和视频流播放类似，需要了解下的就是。
ffmpeg拿avpacket做缓存_FFMPEG结构体：AVPacket解析
weixin_39873356的博客
12-21 342
因为FFmpeg更新的比较快，API也会跟着有所变动，所以声明一下，本文使用的FFmpeg版本为V3.3.5。1.AVPacket简介AVPacket是FFmpeg中很重要的一个数据结构，它保存了解复用(demuxer)之后，解码(decode)之前的数据(仍然是压缩后的数据)和关于这些数据的一些附加的信息，如显示时间戳(pts)，解码时间戳(dts),数据时长(duration)，所在流媒体的索...
【c++】使用FFmpeg库进行视频流处理的
weixin_47564581的博客
12-08 1447
，新版的FFmpeg可能需要做相应的更新。此外，对于实时视频流，循环的方式并不是最优的，因为它会一直运行，最好的方式是将其放在单独的线程中。这两行代码用于初始化FFmpeg库和网络库，确保在使用解封装（flv，mp4，rmvb，avi）功能和编解码器之前进行了初始化。如果解码成功，进行格式转换、缩放，并将RGB数据加载到QImage中。这部分代码用于打开RTSP流或文件流，设置了一些参数以优化流的拉取，例如设置缓存大小、超时时间等。最后释放分配的资源，包括输出缓冲区、帧以及关闭解码器和输入流。
FFmpeg引用计数数据缓冲区相关的结构体：AVBuffer、AVBufferRef简介
崔杰城的博客
07-04 631
AVBuffer是一个用于引用计数数据缓冲区的应用程序编程接口，它表示数据缓冲区本身。它是不透明的，不能被直接访问调用，只能通过AVBufferRef间接访问它。
音视频学习 FFmpeg：音视频缓冲区
C/C++Linux、音视频、DPDK
06-08 1529
ffmpeg有自带缓存区，由于不对外暴露，无法很好的控制，经常出现播放花屏问题，当然我们可以修改源码，但通常做法是，忽略ffmpeg本身缓存区，自己实现缓冲队列，通常播放器底层会有两个队列解码队列(压缩数据) 渲染队列(非压缩数据)由于渲染队列通常有3帧左右的缓存就够了，所以当我们计算播放器的downloadSize的时候，通常说的是解码队列的数据总和，当解码队列为空的时候向上层抛开始缓冲消息，渲染器停止消费，为了播放器顺畅播放（减小卡顿率）当队列里有一定数据的时候抛出缓冲结束消息，渲染器再开始消费。
FFmpeg 抽取出音频流数据
zoutian007的专栏
08-22 2880
这个程序实现了从音视频文件中抽取出音频流数据并保存成wav音频格式文件的功能。 #include "avcodec.h" #include "avformat.h" #include #include #include #include #pragma comment(lib,"avformat.lib") #pragma comment(lib,"avutil.lib
opencv4.1.2 缓存文件（opencv-4.1.2\.cache\ffmpeg）
02-21
1. 解压后,将 .cache文件夹 放入 opencv-4.1.2/ 下, 与`3rdparty/`和`license`同级 2. 再次直接cmake中Configure即可, 不用在线下载ffmpeg/IPPICV包 3. 完全适用opencv4.1.2版本, 其他版本运行出错后查看`CMakeDownloadLog.txt`重新下载对应文件并替换即可 4. github下载慢或下载失败，则追加hosts文件 151.101.108.133 raw.githubusercontent.com
7、FFmpeg 音视频处理
阿牧路泽
08-12 262
音视频处理
音视频ffmpeg笔记（二）
甜筒八部 的专栏
01-12 327
绘制YUV数据 YUV格式 Y明亮度，灰度值。U是色度，V是浓度，UV描述颜色和饱和度。 主要用于电视，亮度信息Y与色彩信息UV分离，没有UV信息就算黑白电视效果。 YUV420 Y:U:V=4:1:1，绝大多数视频是YUV420格式的。如果不是就先转化为YUV420格式然后再渲染 FFmpeg中的YUV数据 FFmpeg解码出来的视频YUV数据是存储在AVFrame中的data里面 Y分量: frame->data[0] U分量: frame->data[1] V分量...
FFmpeg_01_视音频流封装
08-06
本教程将深入讲解FFmpeg在视音频流封装方面的知识，结合C++编程语言进行实现。 FFmpeg 包含了多个核心组件，如libavcodec（编码/解码库）、libavformat（容器格式处理库）和libavfilter（滤镜库），这些组件协同...
C++ 双缓存机制播放音频流(PCM裸流)
03-22
在本文中，我们将深入探讨如何使用C++实现双缓存机制来播放音频流，特别是针对PCM（脉冲编码调制）裸流。PCM是数字音频的一种常见格式，它以原始样点的形式存储声音数据，不包含任何编码或压缩。双缓存机制在处理...
ffmpeg保存视频流
04-20
ffmpeg保存rtsp视频流到文件中
ffmpeg 推流技术
09-28
ffmpeg 推流源码，vs>2012版本可直接编译， 推流接口已经封装好，推流库也是源码，可以自己优化封装库，对于学习推流技术和调用都是很好的资料
android在线边缓存边播放mp4
04-22
android在线边缓存边播放mp4，原理请参考我的博客： http://blog.csdn.net/i5suoi/article/details/51218416
C#FFmpeg拉取RTMP流
06-21
FFmpeg是一款强大的多媒体处理工具，它支持各种视频、音频格式的编码、解码、转换以及流媒体处理。在C#中使用FFmpeg，可以让你的程序具备处理多媒体流的能力，例如从RTMP（Real-Time Messaging Protocol）服务器拉取...
ffmpeg库，实现ffmpeg通过websocket向前端推流
03-12
同时，优化服务器性能，如负载均衡、流缓存策略，以应对大量并发用户。 通过以上步骤，我们可以实现使用FFmpeg库通过WebSocket协议将音视频流推送到前端。这种方式在实时互动应用、在线教育、远程监控等场景中有...
FFmpeg学习6：视音频同步
BrookIcv的博客
09-23 1190
在上一篇文章中，视频和音频是各自独立播放的，并不同步。本文主要描述了如何以音频的播放时长为基准，将视频同步到音频上以实现视音频的同步播放的。主要有以下几个方面的内容 * 视音频同步的简单介绍 * DTS 和 PTS * 计算视频中Frame的显示时间 * 获取Audio clock（audio的播放时长） * 将视频同步到音频上，实现视音频同步播放视音频同步简单介绍一般来说，视频同步指的
FFmpeg 简单应用 - 使用客户端缓存功能转换视频
最新发布
2303_79391681的博客
07-21 599
作为多平台适用的，集音视频录制、转换与推流等众多功能为一体的FFmpeg，在日常生活中也会满足一部分需求。本文主要讲述使用FFmpeg，将缓存视频转化为可观看形式的过程。
ffmpeg学习日记21-缓存AVPacket数据
WenCoo的博客
02-10 896
ffmpeg学习日记21-缓存AVPacket数据 avpacket中存储的是压缩过后的数据，数据量并不是很大，在合成视频之前，需要将该部分数据存在内存中，待合成使用。 创建一个存储器 std::list<AVPacket *> deque; av_read_frame函数读出来avpacket，此处可以将avpacket结构中的数据单独存起来，也可以将整个avpacket结构存储起来，我选择后者的实现方式 while (av_read_frame(&(*ctx->fmt_ct
FFMPEG结合EasyDarwin实现本地摄像头RTSP推流教程
FFmpeg是一个强大的开源多媒体处理工具，它包含了一系列的库，如libavcodec（音频和视频解码器库）和libavformat（音频与视频格式转换库），能够支持多种音频和视频格式的编码、解码、转换和流化操作。在本场景中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值