packet.c

ts流的解复用

#include "packet.h"
#include "ringbuffer.h"


void av_free_packet(AVPacket *pkt)
{
    if (pkt && pkt->destruct) {
        pkt->destruct(pkt);
    }
}

void av_destruct_packet_nofree(AVPacket *pkt)
{
    pkt->data = NULL; pkt->size = 0;
}

void av_destruct_packet(AVPacket *pkt)
{
    free(pkt->data);
    pkt->data = NULL; pkt->size = 0;
}

void av_init_packet(AVPacket *pkt)
{
    pkt->pts   = AV_NOPTS_VALUE;
    pkt->dts   = AV_NOPTS_VALUE;
    pkt->pos   = -1;
    pkt->duration = 0;
    pkt->flags = 0;
    pkt->stream_index = 0;
    pkt->destruct= av_destruct_packet_nofree;
}

int av_new_packet(AVPacket *pkt, int size)
{
    uint8_t *data;
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
        return (-1);
    data = malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
    if (!data)
        return (-1);
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

    av_init_packet(pkt);
    pkt->data = data;
    pkt->size = size;
    pkt->destruct = av_destruct_packet;
    return 0;
}

//int av_get_packet(RingBuffer_s *s, AVPacket *pkt, int size)
//{
//    int ret= av_new_packet(pkt, size);
//
//    if(ret<0)
//        return ret;
//
//    pkt->pos= url_ftell(s);
//
//    ret= get_buffer(s, pkt->data, size);
//    if(ret<=0)
//        av_free_packet(pkt);
//    else
//        pkt->size= ret;
//
//    return ret;
//}

int av_dup_packet(AVPacket *pkt)
{
    if (pkt->destruct != av_destruct_packet) {
        uint8_t *data;
        /* We duplicate the packet and don't forget to add the padding again. */
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
            return (-1);
        data = malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
        if (!data) {
            return (-1);
        }
        memcpy(data, pkt->data, pkt->size);
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
        pkt->data = data;
        pkt->destruct = av_destruct_packet;
    }
    return 0;
}

/* packet queue handling */
void packet_queue_init(PacketQueue *q)
{
    memset(q, 0, sizeof(PacketQueue));
//    q->mutex = RTOS_SemaphoreCreate(1);
//    q->cond = RTOS_MailboxCreate(NULL);
}

void packet_queue_flush(PacketQueue *q)
{
    AVPacketList *pkt, *pkt1;

 //   sem_lock(q->mutex);
    for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
        pkt1 = pkt->next;
        av_free_packet(&pkt->pkt);
        free(&pkt);
    }
    q->last_pkt = NULL;
    q->first_pkt = NULL;
    q->nb_packets = 0;
    q->size = 0;
 //   sem_unlock(q->mutex);
}

void packet_queue_end(PacketQueue *q)
{
    packet_queue_flush(q);
//    RTOS_SemaphoreDestroy(q->mutex);
//    RTOS_MailboxDestroy(q->cond);
}

int packet_queue_put(PacketQueue *q, AVPacket *pkt)
{
    AVPacketList *pkt1;

    /* duplicate the packet */
    //if (/*pkt!=&flush_pkt && */av_dup_packet(pkt) < 0)
    //    return -1;
	if(!q) return -2;

    pkt1 = malloc(sizeof(AVPacketList));
    if (!pkt1)
        return -1;
    pkt1->pkt = *pkt;
    pkt1->next = NULL;


//    sem_lock(q->mutex);

    if (!q->last_pkt)
        q->first_pkt = pkt1;
    else
        q->last_pkt->next = pkt1;
    q->last_pkt = pkt1;
    q->nb_packets++;
    q->size += pkt1->pkt.size;
    /* XXX: should duplicate packet data in DV case */
//    RTOS_MailboxSend(q->cond, NULL);

 //   sem_unlock(q->mutex);
    
    return 0;
}

void packet_queue_abort(PacketQueue *q)
{
//    sem_lock(q->mutex);

    q->abort_request = 1;

//	RTOS_MailboxSend(q->cond, NULL);

 //   sem_unlock(q->mutex);
}

/* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
{
    AVPacketList *pkt1;
    int ret;

 //   sem_lock(q->mutex);
    
    for(;;) {
        if (q->abort_request) {
            ret = -1;
            break;
        }

        pkt1 = q->first_pkt;
        if (pkt1) {
            q->first_pkt = pkt1->next;
            if (!q->first_pkt)
                q->last_pkt = NULL;
            q->nb_packets--;
            q->size -= pkt1->pkt.size;
            *pkt = pkt1->pkt;
            free(pkt1);
            ret = 1;
            break;
        } else if (!block) {
            ret = 0;
            break;
        } else {
        	//阻塞，等待消息
//            RTOS_MailboxWait(q->cond, true);
        }
    }
//    sem_unlock(q->mutex);
    return ret;
}

int av_read_packet(AVFormatContext *s, AVPacket *pkt)
{
	
	return 0;	
}

static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
	return 0;
}

//从buffer里取一个完整的pes帧
//int av_read_frame(AVFormatContext *s, AVPacket *pkt)
//{
//	return 0;
//}