queue implement

最新推荐文章于 2020-02-03 19:53:45 发布
最新推荐文章于 2020-02-03 19:53:45 发布
阅读量626 收藏
点赞数
分类专栏： VLC 文章标签： queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minibird1/article/details/50457873
版权

queue implement reminder.




#ifndef __FF_QUEUE_TEMPLATE__
#define __FF_QUEUE_TEMPLATE__


#include <stdio.h>
#include <errno.h>
#include <assert.h>


#include <SDL/SDL.h>
#include <SDL/SDL_mutex.h>
#include <SDL/SDL_thread.h>


#if 0
#define LOCK_TRACE(tag) av_log(NULL, AV_LOG_DEBUG, "[%s-%d]%s.\n", __func__, __LINE__, tag)
#else
#define LOCK_TRACE(arg...) ((void)0)
#endif


#ifdef __NOTE__   //note only
#define _queue_peek_readable
#define _queue_init 
#define _queue_flush 
#define _queue_abort 
#define _queue_destory 
#define _queue_nb_remaining 
#define _queue_push 
#define _queue_pop 
#define _queue_peek_writable 
#endif




#define QUEUE_TEMPLATE(TYPE)            \
typedef struct TYPE ## _QUEUE {         \
    TYPE **frame;                       \
    int rindex;                         \
    int windex;                         \
    int size;                           \
    int max_size;                       \
    int abort_request;                  \
    SDL_mutex *mutex;                   \
    SDL_cond  *cond;                    \
    TYPE *(*alloc_func)(void);              \
    void (*free_func)(void* unit);      \
}TYPE ## _QUEUE;                        \
                                        \
static inline int TYPE ##_queue_init(TYPE ## _QUEUE *q, int max_size, TYPE *(*alloc_func)(), void (*free_func)(void* unit))        \
{                                                       \
    int i;                                              \
    memset(q, 0, sizeof(TYPE ## _QUEUE));               \
    if (!(q->mutex = SDL_CreateMutex()))                \
        return -ENOMEM;                                 \
    if (!(q->cond = SDL_CreateCond()))                  \
        return -ENOMEM;                                 \
    q->max_size = max_size;                             \
    q->alloc_func = alloc_func;                         \
    q->free_func  = free_func;                          \
    q->frame = (TYPE**)malloc(sizeof(TYPE*)*max_size);   \
    if (!q->frame)                                      \
        return -ENOMEM;                                 \
    for (i=0; i<max_size; i++){                         \
        q->frame[i] = alloc_func ? (alloc_func()) : (TYPE*)malloc(sizeof(TYPE));\
        if (!q->frame[i])                               \
            return -ENOMEM;                             \
    }                                                   \
    return 0;                                           \
}                                                       \
                                                        \
                                                        \
static inline void TYPE ##_queue_flush(TYPE ## _QUEUE *q)      \
{                                                       \
    SDL_LockMutex(q->mutex);                            \
            LOCK_TRACE("Lock");                                       \
    q->size = 0;                                        \
    q->rindex = 0;                                      \
    q->windex = 0;                                      \
    SDL_UnlockMutex(q->mutex);                          \
            LOCK_TRACE("UNLock");                                       \
}                                                       \
                                                        \
static inline void TYPE ##_queue_abort(TYPE ## _QUEUE *q)      \
{                                                       \
            LOCK_TRACE("Lock");                                       \
    SDL_LockMutex(q->mutex);                            \
    q->abort_request = 1;                               \
    SDL_CondSignal(q->cond);                            \
    SDL_UnlockMutex(q->mutex);                          \
            LOCK_TRACE("UNLock");                                       \
}                                                       \
                                                        \
static inline void TYPE ##_queue_destory(TYPE ## _QUEUE *q)           \
{                                                       \
    int i;                                              \
    LOCK_TRACE("Lock");                                       \
    SDL_LockMutex(q->mutex);                            \
    for (i = 0; i < q->max_size; i++) {                 \
        if (q->free_func)                               \
            q->free_func(q->frame[i]);                  \
        else                                            \
            free(q->frame[i]);                          \
    }                                                   \
    free(q->frame);                                     \
    SDL_UnlockMutex(q->mutex);                          \
            LOCK_TRACE("UNLock");                                       \
    SDL_DestroyMutex(q->mutex);                         \
    SDL_DestroyCond(q->cond);                           \
}                                                       \
                                                        \
static inline int TYPE ##_queue_nb_remaining(TYPE ## _QUEUE *q)         \
    {return q->size;}                                    \
                                                        \
static inline void TYPE ##_queue_signal(TYPE ## _QUEUE *q)                 \
{                                                       \
    SDL_LockMutex(q->mutex);                            \
            LOCK_TRACE("Lock");                                       \
    SDL_CondSignal(q->cond);                            \
    SDL_UnlockMutex(q->mutex);                            \
            LOCK_TRACE("UNLock");                                       \
}                                                       \
                                                        \
static inline void TYPE ##_queue_push(TYPE ## _QUEUE *q)                   \
{                                                       \
    if (++q->windex == q->max_size)                     \
        q->windex = 0;                                  \
        LOCK_TRACE("Lock");                                       \
    SDL_LockMutex(q->mutex);                            \
    q->size++;                                          \
    SDL_CondSignal(q->cond);                            \
    SDL_UnlockMutex(q->mutex);                          \
        LOCK_TRACE("UNLock");                                       \
}                                                       \
                                                        \
static inline void *TYPE ##_queue_peek_writable(TYPE ## _QUEUE *q, int block)     \
{                                                       \
        LOCK_TRACE("Lock");                                       \
    SDL_LockMutex(q->mutex);                            \
    while (q->size >= q->max_size && !q->abort_request) \
    {                                                   \
        if (block){                                     \
            LOCK_TRACE("Wait");                         \
            SDL_CondWait(q->cond, q->mutex);            \
        }                                               \
        else{                                           \
            SDL_UnlockMutex(q->mutex);                  \
            LOCK_TRACE("UNLock");                       \
            return NULL;                                \
        }                                               \
    }                                                   \
    SDL_UnlockMutex(q->mutex);                          \
    LOCK_TRACE("UNLock");                                       \
    return (q->abort_request) ? NULL : q->frame[q->windex];     \
}                                                       \
                                                        \
static inline void TYPE ##_queue_pop(TYPE ## _QUEUE *q)                            \
{                                                       \
    if (++q->rindex == q->max_size)                     \
        q->rindex = 0;                                  \
        LOCK_TRACE("Lock");                                       \
    SDL_LockMutex(q->mutex);                            \
    q->size--;                                          \
        LOCK_TRACE("Signal");                         \
    SDL_CondSignal(q->cond);                            \
    SDL_UnlockMutex(q->mutex);                          \
        LOCK_TRACE("UNLock");                                       \
}                                                       \
                                                        \
static inline void *TYPE ##_queue_peek_readable(TYPE ## _QUEUE *q, int block) \
{                                                       \
        LOCK_TRACE("Lock");                                       \
    SDL_LockMutex(q->mutex);                            \
    while (q->size <= 0 && !q->abort_request)           \
    {                                                   \
        if (block){                                     \
            LOCK_TRACE("Wait");                         \
            SDL_CondWait(q->cond, q->mutex);            \
        }                                               \
        else{                                           \
            SDL_UnlockMutex(q->mutex);                  \
            LOCK_TRACE("UNLock");                       \
            return NULL;                                \
        }                                               \
    }                                                   \
    SDL_UnlockMutex(q->mutex);                          \
            LOCK_TRACE("UNLock");                                       \
    return (q->abort_request) ? NULL : q->frame[q->rindex];     \
}






#ifdef __TEST__QUEUE__
typedef int MINT;


MINT *alloc_mint()
{
    MINT *ptr = (MINT*)malloc(sizeof(MINT));
    memset(ptr, 0, sizeof(MINT));
    return ptr;
}


void free_mint(void *mint)
{
    free((int *)mint);
}




QUEUE_TEMPLATE(MINT);


MINT_QUEUE myqueue;


#define MAX_QUEUE_SIZE 32


int main(int argc, char *argv[])
{
    int i=0;
    int size = 0;
    MINT *unit;
    //MINT_queue_init(&myqueue, 8, NULL, NULL);
    MINT_queue_init(&myqueue, MAX_QUEUE_SIZE, alloc_mint, free_mint);
    assert(MINT_queue_nb_remaining(&myqueue) == 0);


    for (i=0;i<MAX_QUEUE_SIZE/2;i++)
    {
        if ((unit = MINT_queue_peek_writable(&myqueue, 0)) != NULL)
        {
            *unit = i;
            MINT_queue_push(&myqueue);
            assert((MINT_queue_nb_remaining(&myqueue) == (i+1)) ||
                (printf("nb[%d]=%d.\n", MINT_queue_nb_remaining(&myqueue), i+1), 0));
        }
    }
    assert(MINT_queue_nb_remaining(&myqueue) == MAX_QUEUE_SIZE/2);


    size = MINT_queue_nb_remaining(&myqueue);
    for (i=0;i<MAX_QUEUE_SIZE/2;i++)
    {
        if ((unit = MINT_queue_peek_readable(&myqueue, 0)) != NULL)
        {
            assert((*unit == i) ||
                (printf("unit[%d]=%d.\n", *unit, i), 0));
            MINT_queue_pop(&myqueue);
            assert(MINT_queue_nb_remaining(&myqueue) == size-1-i);
        }
    }
    assert(MINT_queue_nb_remaining(&myqueue) == 0);


    MINT_queue_flush(&myqueue);
    assert(MINT_queue_nb_remaining(&myqueue) == 0);


    printf("nb after flush: %d.\n", MINT_queue_nb_remaining(&myqueue));
    MINT_queue_destory(&myqueue);




    return 0;
}
#endif




#endif


minibird1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ffplay中的FrameQueue的自我理解
u010289908的专栏
03-03 2975
最近在研究ffplay，以下是本人今天在研究FrameQueue的时候整理的笔记，如有错误还请有心人指出来~ //这个队列是一个循环队列，windex是指其中的首元素，rindex是指其中的尾部元素. typedef struct FrameQueue {                  Frame queue[FRAME_QUEUE_SIZE ];                  i
Implement Queue using Stacks
xiaohuihui52309的专栏
05-03 194
Implement Queue using Stacks Implement the following operations of a queue using stacks. push(x) -- Push element x to the back of queue.pop() -- Removes the element from in front of queue.peek
232. Implement Queue using Stacks
万里归来少年心
02-03 379
Implement the following operations of a queue using stacks. push(x) -- Push element x to the back of queue. pop() -- Removes the element from in front of queue. peek() -- Get the front element. em...
LeetCode:Implement Queue using Stacks
walker lee
05-22 3777
Implement Queue using Stacks Total Accepted: 44005 Total Submissions: 129236 Difficulty: Easy Implement the following operations of a queue using stacks. push(x) -- Push e
python implement queue
screaming的博客
03-02 437
用Python实现队列 2012-12-14      1 个评论       作者：buaa_shang 收藏    我要投稿 [python]   #!/usr/bin/env python      queue = []      def enQ():       queue.append(raw_input('Enter new string: ').
Implement queue with Python list
yangxkl的专栏
03-24 1063
# Completed implementation of a queue ADT class Queue: def __init__(self): self.data = [] def is_empty(self): return self.data == [] def enqueue(self, item): self
leetcode Implement Queue using Stacks
你说你逗不逗 *^_^* 的博客
07-14 602
继续刷题。编译CM12.1刷机怎么着都有问题，烦人的把之前下载的源码直接删掉，重新下载，在下载源码期间继续刷题，希望这个easy不要把我虐成狗。 其实主要问题是自己米有java基础知识，幸亏会点C，可以根据C又得东西查java，但这样的一个弊端时，java把C很多东西封装成了自己的类，很多东西我并不知道有那个东西的存在。。  不废话了，看题； 一.  题目   Implemen
LeetCode --- 232. Implement Queue using Stacks
MissXy_的博客
03-27 220
232. Implement Queue using Stacks Difficulty: Easy Implement the following operations of a queue using stacks. push(x) – Push element x to the back of queue. pop() – Removes the element from in front...
implement-queue-module2
03-14
本项目“implement-queue-module2”显然关注于创建和实现一个Java中的队列模块。 在Java中，可以使用多种方式来实现队列，例如使用数组、链表或者Java集合框架中的Queue接口。以下是对这个模块可能涉及的关键知识点...
leetcodepushfront-implement-queue-using-stacks:使用栈实现队列
07-07
queue.push(1); queue.push(2); queue.peek(); // returns 1 queue.pop(); // returns 1 queue.empty(); // returns false 笔记： 您必须仅使用堆栈的标准操作——这意味着只有推到顶部、从顶部查看/弹出、大小和为...
前端大厂最新面试题-implement-queue-using-stack.docx
06-06
前端大厂最新面试题-implement-queue-using-stack.docx
leetcodepushfront-LeetCode_232--Implement-Queue-using-Stacks:LeetCode_2
07-07
推前LeetCode_232--Implement-Queue-using-Stacks 使用堆栈实现队列的以下操作。 push(x) -- 将元素 x 推到队列的后面。 pop()——从队列前面移除元素。 peek() -- 获取最前面的元素。 empty() -- 返回队列是否为空...
232.Implement Queue using Stacks用栈实现队列【LeetCode单题讲解系列】
08-31
232.Implement_Queue_using_Stacks用栈实现队列【LeetCode单题讲解系列】
(java)Implement Queue using Stacks
martinmateng的博客
11-16 249
Implement the following operations of a queue using stacks. push(x) -- Push element x to the back of queue.pop() -- Removes the element from in front of queue.peek() -- Get the front element.empty(
VLC contrib 之ffmpeg 编译
minibird1的专栏
12-18 1497
VLC 默认支持RTMP，trace code 发现协议相关code 竟然在libavformat 里面。。囧。。只好再build ffmpeg了。 ffmpeg 最难办的就是怕版本跟现有的不match，导致跑不通。。 还记得compile vlc 时候这句否？ $ sudo apt-get build-dep vlc 现在反其道而行之，确定libavformat 的版本：
2024年公关服务行业分析报告.pptx
07-09
行业报告
惠州市建筑物矢量数据（Shp格式+带高度）.txt
最新发布
07-09
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
implement queue of your own
04-03
As an AI language model, I cannot implement code on my own. However, I can provide a sample implementation of a queue in Python: ```python class Queue: def __init__(self): self.items = [] def is_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值