queue.h

AU1200嵌入式处理器媒体加速引擎（mae）的驱动

/*
 *  Linked list macros for Alchemy MAE driver
 *
 * Copyright 2004 Advanced Micro Devices, Inc
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
 *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 *  NO  EVENT  SHALL   THE AUTHOR  BE	LIABLE FOR ANY   DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
 *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  You should have received a copy of the  GNU General Public License along
 *  with this program; if not, write  to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef _DSS_SRC_INCLUDE_LL_H
#define _DSS_SRC_INCLUDE_LL_H

#define USE_MACRO 1
#ifdef USE_MACRO
#define DLCL_APPEND(LL_TYPE, QUEUE, ELEMENT)	\
{\
    LL_TYPE *curr_elem;\
    if (*QUEUE == NULL) {\
    /* first element in the list */\
    *QUEUE = ELEMENT;\
    ELEMENT->next = ELEMENT->prev = ELEMENT;\
    }\
    else\
    {\
    curr_elem = *QUEUE->prev;\
    curr_elem->next = ELEMENT;\
    ELEMENT->next = *QUEUE;\
    ELEMENT->prev = curr_elem;\
    *QUEUE->prev = ELEMENT;\
    }\
}

#define DLCL_POP(LL_TYPE, QUEUE, ELEMENT)	\
{\
     LL_TYPE *curr_elem;\
     if( *QUEUE)\
     {\
        if( *QUEUE->next == *QUEUE)\
        {\
            /* last element being popped */\
            ELEMENT = *QUEUE;\
            *QUEUE = NULL;\
        }\
        else\
        {\
            curr_elem = *QUEUE->prev;\
            ELEMENT = *QUEUE;\
            curr_elem->next = *QUEUE->next;\
            *QUEUE->next->prev = curr_elem;\
            *QUEUE = *QUEUE->next;\
        }\
     }\
     else\
        ELEMENT = NULL;\
}
#else
void DLCL_APPEND(LL_TYPE, QUEUE, ELEMENT)	
{
    LL_TYPE *curr_elem;
    if (*QUEUE == NULL) {
    /* first element in the list */
    *QUEUE = ELEMENT;
    ELEMENT->next = ELEMENT->prev = ELEMENT;
    }
    else
    {
    curr_elem = *QUEUE->prev;
    curr_elem->next = ELEMENT;
    ELEMENT->next = *QUEUE;
    ELEMENT->prev = curr_elem;
    *QUEUE->prev = ELEMENT;
    }
}

void DLCL_POP(LL_TYPE, QUEUE, ELEMENT)	
{
     LL_TYPE *curr_elem;
     if( *QUEUE)
     {
        if( *QUEUE->next == *QUEUE)
        {
            /* last element being popped */
            ELEMENT = *QUEUE;
            *QUEUE = NULL;
        }
        else
        {
            curr_elem = *QUEUE->prev;
            ELEMENT = *QUEUE;\
            curr_elem->next = *QUEUE->next;
            *QUEUE->next->prev = curr_elem;
            *QUEUE = *QUEUE->next;\
        }
     }
     else
        ELEMENT = NULL;
}
#endif
#define DLCL_REMOVE(LL_TYPE, QUEUE, ELEMENT)	\
{\
     LL_TYPE *curr_elem;\
     if( (*QUEUE) && (ELEMENT)) \
     {\
        if( ELEMENT->next == ELEMENT)\
        {\
            /* last element being removed */\
            *QUEUE = NULL;\
        }\
        else\
        {\
            curr_elem = ELEMENT->prev;\
            curr_elem->next = ELEMENT->next;\
            ELEMENT->next->prev = curr_elem;\
            if(*QUEUE == ELEMENT) \
                *QUEUE = curr_elem; \
        }\
     }\
     else\
        ELEMENT = NULL;\
}


#define DLCL_INSERT_AFTER(LL_TYPE, ELEMENT, PELEMENT)	\
{\
    LL_TYPE *curr_elem;\
    curr_elem = PELEMENT->next;\
    PELEMENT->next = ELEMENT;\
    ELEMENT->next = curr_elem;\
    curr_elem->prev = ELEMENT;\
    ELEMENT->prev = PELEMENT;\
}
 
#if 0
/********************************************************************/
/*
 * This macro appends ELEMENT to the end of a list
 */
#define DLCL_APPEND(LL_TYPE, QUEUE, ELEMENT)	\
	LL_APPEND_NP(LL_TYPE, QUEUE, ELEMENT, next, prev)

/********************************************************************/
/*
 * This macro removes the head ELEMENT from the list.
 */
#define DLCL_POP(LL_TYPE, QUEUE, ELEMENT)	\
	ELEMENT = QUEUE;                        \
	LL_REMOVE_NP(LL_TYPE, QUEUE, ELEMENT, next, prev)

/********************************************************************/
/*
 * This macro removes ELEMENT from the list.
 */
#define LL_REMOVE(LL_TYPE, QUEUE, ELEMENT)	\
	LL_REMOVE_NP(LL_TYPE, QUEUE, ELEMENT, next, prev)

/********************************************************************/
/*
 * This macro extracts ELEMENT from the list. It doesn't
 * update the list head.
 */
#define LL_EXTRACT(LL_TYPE, ELEMENT)	\
	LL_EXTRACT_NP(LL_TYPE, ELEMENT, next, prev)

/********************************************************************/
/*
 * This macro inserts ELEMENT into the list before NELEMENT
 */
#define LL_INSERT_BEFORE(LL_TYPE, ELEMENT, NELEMENT)	\
	LL_INSERT_BEFORE_NP(LL_TYPE, ELEMENT, NELEMENT, next, prev)

/********************************************************************/
/*
 * This macro inserts ELEMENT into the list after PELEMENT
 */
#define DLCL_INSERT_AFTER(LL_TYPE, ELEMENT, PELEMENT)	\
	LL_INSERT_AFTER_NP(LL_TYPE, ELEMENT, PELEMENT, next, prev)

/********************************************************************/
/*
 * This macro inserts LIST into the list before element NELEMENT.
 */
#define LL_INSERT_LIST_BEFORE(LL_TYPE, ELEMENT, NELEMENT)	\
	LL_INSERT_LIST_BEFORE_NP(LL_TYPE, LIST, NLIST, next, prev)

/********************************************************************/
/*
 * This macro inserts LIST into the list after element PELEMENT
 */
#define LL_INSERT_LIST_AFTER(LL_TYPE, ELEMENT, PELEMENT)	\
	LL_INSERT_LIST_AFTER_NP(LL_TYPE, LIST, PLIST, next, prev)

/********************************************************************/
/********************************************************************/
/********************************************************************/
/********************************************************************/
/*
 * This macro appends ELEMENT to the end of a list
 */
#define LL_APPEND_NP(LL_TYPE, QUEUE, ELEMENT, NEXT, PREV)	\
{										\
	LL_TYPE *fel, *lel;				\
	if ((fel = QUEUE) == NULL)			\
	{									\
		QUEUE = ELEMENT->NEXT = ELEMENT->PREV = ELEMENT;	\
	}									\
	else								\
	{									\
		lel = fel->PREV;				\
		lel->NEXT = ELEMENT;			\
		ELEMENT->PREV = lel;			\
		ELEMENT->NEXT = fel;			\
		fel->PREV = ELEMENT;			\
	}									\
}

/********************************************************************/
/*
 * This macro removes ELEMENT from the list.
 *
 * NOTE: This requires that ELEMENT actually be on the list!
 */
#define LL_REMOVE_NP(LL_TYPE, QUEUE, ELEMENT, NEXT, PREV)	\
{										\
	LL_TYPE *nel, *pel;				\
	if (QUEUE != NULL)					\
	{									\
		nel = ELEMENT->NEXT;			\
		pel = ELEMENT->PREV;			\
		if (QUEUE == ELEMENT)			\
		{								\
			/* FIX!!!! should use (nel == pel) */	\
			/*if (ELEMENT->NEXT == ELEMENT)	*/			\
            if (nel == pel)     \
			{							\
				/*ELEMENT->NEXT = ELEMENT->PREV = NULL;*/		\
				QUEUE = NULL;			\
			}							\
			else						\
			{							\
				pel->NEXT = nel;		\
				nel->PREV = pel;		\
				QUEUE = nel;			\
			}							\
		}								\
		else							\
		{								\
			pel->NEXT = nel;			\
			nel->PREV = pel;			\
		}								\
	}									\
}


/********************************************************************/
/********************************************************************/
/********************************************************************/
/********************************************************************/

/*
 * The following insert and extract macros simply manipulate the
 * element(s) provided. That is, the list head is not modified.
 * Furthermore, it is REQUIRED that the ELEMENT be valid (ie not NULL)
 */

/*
 * This macro extracts ELEMENT from the list. It doesn't
 * change the list head.
 *
 * NOTE: This requires that the element actually be on the list!
 */
#define LL_EXTRACT_NP(LL_TYPE, ELEMENT, NEXT, PREV)	\
{									\
	LL_TYPE *nel, *pel;			\
	nel = ELEMENT->NEXT;			\
	pel = ELEMENT->PREV;			\
	pel->NEXT = nel;				\
	nel->PREV = pel;				\
}

/********************************************************************/
/*
 * This macro inserts ELEMENT into the list before NELEMENT.
 */
#define LL_INSERT_BEFORE_NP(LL_TYPE, ELEMENT, NELEMENT, NEXT, PREV)	\
{									\
	LL_TYPE *pel;					\
	pel = NELEMENT->PREV;			\
	pel->NEXT = ELEMENT;			\
	ELEMENT->NEXT = NELEMENT;		\
	NELEMENT->PREV = ELEMENT;		\
	ELEMENT->PREV = pel;			\
}

/********************************************************************/
/*
 * This macro inserts ELEMENT into the list after PELEMENT.
 */
#define LL_INSERT_AFTER_NP(LL_TYPE, ELEMENT, PELEMENT, NEXT, PREV)	\
{									\
	LL_TYPE *nel;					\
	nel = PELEMENT->NEXT;			\
	PELEMENT->NEXT = ELEMENT;		\
	ELEMENT->NEXT = nel;			\
	nel->PREV = ELEMENT;			\
	ELEMENT->PREV = PELEMENT; 		\
}

/********************************************************************/

/*
 * The following insert macros operate on lists, but do not modify
 * the list head.
 * Furthermore, it is REQUIRED that the LIST be valid (ie not NULL)
 */

/*
 * This macro inserts LIST into the list BEFORE element NELEMENT.
 */
#define LL_INSERT_LIST_BEFORE_NP(LL_TYPE, LIST, NELEMENT, NEXT, PREV)	\
{									\
	LL_TYPE *nel, *pel, *lf, *ll;	\
	lf = LIST; ll = lf->PREV;		\
	nel = NELEMENT; pel = nel->PREV;\
	ll->NEXT = nel;					\
	nel->PREV = ll;					\
	pel->NEXT = lf;					\
	lf->PREV = pel;					\
}

/********************************************************************/
/*
 * This macro inserts LIST into the list AFTER element PELEMENT
 */
#define LL_INSERT_LIST_AFTER_NP(LL_TYPE, LIST, PELEMENT, NEXT, PREV)	\
{									\
	LL_TYPE *nel, *pel, *lf, *ll;	\
	lf = LIST; ll = lf->PREV;		\
	pel = PELEMENT; nel = pel->NEXT;\
	ll->NEXT = nel;					\
	nel->PREV = ll;					\
	pel->NEXT = lf;					\
	lf->PREV = pel;					\
}

/********************************************************************/
 #endif /* if 0 */
 
#endif	/* _DSS_SRC_INCLUDE_LL_H */