/*ringbuf .c*/

#include<stdio.h>
#include<ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdint.h>
#include <sys/types.h>

#include "ringfifo.h"
#include "rtputils.h" 
#include "rtspservice.h" 
#define NMAX 32

static volatile int iput = 0; /* 环形缓冲区的当前放入位置 */
static volatile int iget = 0; /* 缓冲区的当前取出位置 */
static volatile int n = 0; /* 环形缓冲区中的元素总数量 */

struct ringbuf ringfifo[NMAX];
extern int UpdateSpsOrPps(unsigned char *data,int frame_type,int len);
/* 环形缓冲区的地址编号计算函数，如果到达唤醒缓冲区的尾部，将绕回到头部。
环形缓冲区的有效地址编号为：0到(NMAX-1)
*/
void ringmalloc(int size)
{
    int i;
    for(i =0; i<NMAX; i++)
    {
        ringfifo[i].buffer = malloc(size);
        ringfifo[i].size = 0;
        ringfifo[i].frame_type = 0;
       // printf("FIFO INFO:idx:%d,len:%d,ptr:%x\n",i,ringfifo[i].size,(int)(ringfifo[i].buffer));
    }
    iput = 0; /* 环形缓冲区的当前放入位置 */
    iget = 0; /* 缓冲区的当前取出位置 */
    n = 0; /* 环形缓冲区中的元素总数量 */
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
void ringreset()
{
    iput = 0; /* 环形缓冲区的当前放入位置 */
    iget = 0; /* 缓冲区的当前取出位置 */
    n = 0; /* 环形缓冲区中的元素总数量 */
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
void ringfree(void)
{
    int i;
    printf("begin free mem\n");
    for(i =0; i<NMAX; i++)
    {
       // printf("FREE FIFO INFO:idx:%d,len:%d,ptr:%x\n",i,ringfifo[i].size,(int)(ringfifo[i].buffer));
        free(ringfifo[i].buffer);
        ringfifo[i].size = 0;
    }
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
int addring(int i)
{
    return (i+1) == NMAX ? 0 : i+1;
}

/**************************************************************************************************
**
**
**
**************************************************************************************************/
/* 从环形缓冲区中取一个元素 */

int ringget(struct ringbuf *getinfo)
{
    int Pos;
    if(n>0)
    {
        Pos = iget;
        iget = addring(iget);
        n--;
        getinfo->buffer = (ringfifo[Pos].buffer);
        getinfo->frame_type = ringfifo[Pos].frame_type;
        getinfo->size = ringfifo[Pos].size;
        //printf("Get FIFO INFO:idx:%d,len:%d,ptr:%x,type:%d\n",Pos,getinfo->size,(int)(getinfo->buffer),getinfo->frame_type);
        return ringfifo[Pos].size;
    } 
    else
    {
        //printf("Buffer is empty\n");
        return 0;
    }
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
/* 向环形缓冲区中放入一个元素*/
void ringput(unsigned char *buffer,int size,int encode_type)
{

    if(n<NMAX)
    {
        memcpy(ringfifo[iput].buffer,buffer,size);
        ringfifo[iput].size= size;
        ringfifo[iput].frame_type = encode_type;
        //printf("Put FIFO INFO:idx:%d,len:%d,ptr:%x,type:%d\n",iput,ringfifo[iput].size,(int)(ringfifo[iput].buffer),ringfifo[iput].frame_type);
        iput = addring(iput);
        n++;
    }
    else
    {
        //  printf("Buffer is full\n");
    }
}

static void printf_data(uint8_t *data, int size)
{
    static char resp_str[1290];
    memset(resp_str, 0x0, sizeof(resp_str));

    if (size > (sizeof(resp_str) / 3))
    {
        size = sizeof(resp_str) / 3;
    }

    int index = 0;

    for(int i = 0; i < size; i++)
    {
        sprintf(resp_str + index, "%02x ", data[i]);
        index = strlen(resp_str);

        if (index > 512)
        {
            break;
        }
    }

    printf("data %d:%s \r\n", size, resp_str);
}

/**************************************************************************************************
**
**
**
**************************************************************************************************/
static volatile int found_sps_pps = 0;
int HisiPutH264DataToBuffer(uint8_t *frame_data, int frame_len)
{
	int i,j;
	int len=frame_len,off=0,len2=2;
	unsigned char *pstr;
	int iframe=0; 


    if(n<NMAX)
    { 
        
	memcpy(ringfifo[iput].buffer+off, frame_data, frame_len); 
	pstr = frame_data;
	
	if(pstr[4]==0x67 && !found_sps_pps)
	{
		uint8_t *p_sps_data = frame_data+5;//00 00 00 01 67
		int sps_len = frame_len - 5;
		int  i = 0;
		int pps_len = 0;
		int found_pps = 0;
		//printf_data(frame_data, frame_len);
		while(i < frame_len-5){
			//pps
			if ((*(p_sps_data+i) == 0x00) && *(p_sps_data+i +1)==0x00 && *(p_sps_data+i +2) == 0x00 && *(p_sps_data+i +3) == 0x01 && *(p_sps_data+i +4) == 0x68){
				//pps
				found_pps = 1;
				sps_len = i;//26-8
				pps_len = 4 ;//8
				found_sps_pps = 1;
				printf("found pps, sps_len:%d, pps_len:%d", sps_len, pps_len);
				break;
			}
			i++;
		}  
		 
		UpdateSps(frame_data+4, sps_len+1);
		printf_data(frame_data+4, sps_len+1);
		
		if (found_pps){
			
		      printf_data(p_sps_data+i+4, 4);
		      UpdatePps(p_sps_data+i+4, 4);
		}
		
		iframe=1;
	}else if(pstr[4]==0x68)
	{
		printf_data(frame_data, frame_len);
		UpdatePps(ringfifo[iput].buffer,4);
	}else{
		
	}
  
        ringfifo[iput].size= frame_len;
	if(iframe) {
		ringfifo[iput].frame_type = FRAME_TYPE_I;
	}else{
		ringfifo[iput].frame_type = FRAME_TYPE_P;
	}
        //printf("** add %d len:%d\n", iput, frame_len);
        iput = addring(iput);
        n++;
    }

	return 0;
}