#include "parser_callback.h"

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include "types.h"

parser_callback::parser_callback(std::list<AVPacket> *videoList, std::list<AVPacket> *audioList,
                                 Cond *condVideo, Cond *condAudio)
    : mConditon_Video(condVideo),
      mVideoPacktList(videoList),
      mConditon_Audio(condAudio),
      mAudioPacktList(audioList),
      quit_(0) {
}

parser_callback::~parser_callback() {
}

int parser_callback::push_packet(const packet_t* pkt, const av_type_t type) {


    while (isVideoQueneFull() || isAudioQueneFull()) {
        mSleep(1000);
    }
    if (quit_) return 0;

    if (type == AV_VIDEO) {
        AVPacket *avPacket = av_packet_alloc();
        avPacket->data = (uint8_t *)malloc(pkt->length);
        memcpy(avPacket->data, pkt->data, pkt->length);
        avPacket->size = pkt->length;
//        printf("pkt->dts:%d, pkt->pts:%d\n", pkt->dts, pkt->pts);
        avPacket->dts = pkt->dts;
        avPacket->pts = pkt->pts;
        avPacket->stream_index = type;
        inputVideoQuene(*avPacket);
    } else if (type == AV_AUDIO) {
        AVPacket *avPacket = av_packet_alloc();
        avPacket->data = (uint8_t *)malloc(pkt->length);
        memcpy(avPacket->data, pkt->data, pkt->length);
        avPacket->size = pkt->length;
        avPacket->dts = pkt->dts;
        avPacket->pts = pkt->pts;
        avPacket->stream_index = type;
        inputAudioQuene(*avPacket);
    }

    free(pkt->data);
    free((void*)pkt);
    return (int)pkt->length;
}

int parser_callback::open_codec(const int codec_type, const av_type_t type) {
	return 0;
}

int parser_callback::is_quit() {
	return quit_;
}

int parser_callback::quit() {
	quit_ = 1;
	return 0;
}

int parser_callback::push_finish() {
	return 0;
}

bool parser_callback::inputVideoQuene(const AVPacket &pkt)
{
    if (av_dup_packet((AVPacket*)&pkt) < 0)
    {
        printf("ERROR: av_dup_packet((AVPacket*)&pkt) < 0");
        return false;
    }

    mConditon_Video->Lock();
    mVideoPacktList->push_back(pkt);
    mConditon_Video->Signal();
    mConditon_Video->Unlock();

    return true;
}

bool parser_callback::isVideoQueneFull()
{
//    mConditon_Video->Lock();
    bool ret = mVideoPacktList->size() > MAX_VIDEO_SIZE;
//    mConditon_Video->Signal();
//    mConditon_Video->Unlock();

    return ret;
}

bool parser_callback::inputAudioQuene(const AVPacket &pkt)
{
    if (av_dup_packet((AVPacket*)&pkt) < 0)
    {
        printf("ERROR: av_dup_packet((AVPacket*)&pkt) < 0");
        return false;
    }

    mConditon_Audio->Lock();
    mAudioPacktList->push_back(pkt);
    mConditon_Audio->Signal();
    mConditon_Audio->Unlock();

    return true;
}

bool parser_callback::isAudioQueneFull()
{
//    mConditon_Audio->Lock();
    bool ret = mAudioPacktList->size() > MAX_AUDIO_SIZE;
//    mConditon_Audio->Signal();
//    mConditon_Audio->Unlock();

    return ret;
}