PeerStreamer

/*

 *  Copyright (c) 2009-2011 Carmelo Daniele, Dario Marchese, Diego Reforgiato, Giuseppe Tropea

 *  developed for the Napa-Wine EU project. See www.napa-wine.eu

 *

 *  This is free software; see lgpl-2.1.txt

 */

#include "player_defines.h"

#include "chunker_player.h"

#include "player_gui.h"

#include "player_core.h"

#include "player_stats.h"

#include <assert.h>

#include <time.h>

void SaveFrame(AVFrame *pFrame, int width, int height);

int VideoCallback(void *valthread);

int CollectStatisticsThread(void *params);

void AudioCallback(void *userdata, Uint8 *stream, int len);

void PacketQueueClearStats(PacketQueue *q);

void ChunkerPlayerCore_Pause();

//int lastCheckedVideoFrame = -1;

long int last_video_frame_extracted = -1;

int timeval_subtract(struct timeval* x, struct timeval* y, struct timeval* result)

{

  // Perform the carry for the later subtraction by updating y.

  if (x->tv_usec < y->tv_usec)

  {

    int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;

    y->tv_usec -= 1000000 * nsec;

    y->tv_sec += nsec;

  }

  if (x->tv_usec - y->tv_usec > 1000000)

  {

    int nsec = (x->tv_usec - y->tv_usec) / 1000000;

    y->tv_usec += 1000000 * nsec;

    y->tv_sec -= nsec;

  }

  // Compute the time remaining to wait. tv_usec is certainly positive.

  result->tv_sec = x->tv_sec - y->tv_sec;

  result->tv_usec = x->tv_usec - y->tv_usec;

  // Return 1 if result is negative.

  return x->tv_sec < y->tv_sec;

}

void PacketQueueInit(PacketQueue *q, short int Type)

{

#ifdef DEBUG_QUEUE

        printf("QUEUE: INIT BEGIN: NPackets=%d Type=%s\n", q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO");

#endif

        memset(q,0,sizeof(PacketQueue));

        q->mutex = SDL_CreateMutex();

        QueueFillingMode=1;

        q->queueType=Type;

        q->last_frame_extracted = -1;

        q->first_pkt= NULL;

        //q->last_pkt = NULL;

        q->nb_packets = 0;

        q->size = 0;

        q->density= 0.0;

        FirstTime = 1;

        FirstTimeAudio = 1;

        //init up statistics

        q->PacketHistory.Mutex = SDL_CreateMutex();

        PacketQueueClearStats(q);

#ifdef DEBUG_QUEUE

        printf("QUEUE: INIT END: NPackets=%d Type=%s\n", q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO");

#endif

}

void PacketQueueReset(PacketQueue *q)

{

        AVPacketList *tmp,*tmp1;

#ifdef DEBUG_QUEUE

        printf("QUEUE: RESET BEGIN: NPackets=%d Type=%s LastExtr=%d\n", q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO", q->last_frame_extracted);

#endif

        SDL_LockMutex(q->mutex);

        tmp = q->first_pkt;

        while(tmp) {

                tmp1 = tmp;

                tmp = tmp->next;

                av_free_packet(&(tmp1->pkt));

                av_free(tmp1);

#ifdef DEBUG_QUEUE

                printf("F ");

#endif

                q->PacketHistory.LostCount++;

        }

#ifdef DEBUG_QUEUE

        printf("\n");

#endif

        QueueFillingMode=1;

        q->last_frame_extracted = -1;

        // on queue reset do not reset loss count

        // (loss count reset is done on queue init, ie channel switch)

        q->density=0.0;

        q->first_pkt= NULL;

        //q->last_pkt = NULL;

        q->nb_packets = 0;

        q->size = 0;

        FirstTime = 1;

        FirstTimeAudio = 1;

        //clean up statistics

        PacketQueueClearStats(q);

#ifdef DEBUG_QUEUE

        printf("QUEUE: RESET END: NPackets=%d Type=%s LastExtr=%d\n", q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO", q->last_frame_extracted);

#endif

        SDL_UnlockMutex(q->mutex);

}

void PacketQueueClearStats(PacketQueue *q)

{

        sprintf(q->stats_message, "%s", "\n");

        int i;

        memset((void*)q->PacketHistory.History, 0, sizeof(SHistoryElement)*QUEUE_HISTORY_SIZE);

        for(i=0; i<QUEUE_HISTORY_SIZE; i++)

        {

                q->PacketHistory.History[i].Statistics.LastIFrameDistance = -1;

                q->PacketHistory.History[i].Status = -1;

        }

        q->PacketHistory.Index = q->PacketHistory.LogIndex = 0;

        q->PacketHistory.Index = q->PacketHistory.QoEIndex = 0;

        q->PacketHistory.LostCount = q->PacketHistory.PlayedCount = q->PacketHistory.SkipCount = 0;

}

int ChunkerPlayerCore_PacketQueuePut(PacketQueue *q, AVPacket *pkt)

{

        //~ printf("\tSTREAM_INDEX=%d\n", pkt->stream_index);

        short int skip = 0;

        AVPacketList *pkt1, *tmp, *prevtmp;

        int res = 0;

        if(q->nb_packets > queue_filling_threshold*QUEUE_MAX_GROW_FACTOR) {

#ifdef DEBUG_QUEUE

                printf("QUEUE: PUT i have TOO MANY packets %d Type=%s, RESETTING\n", q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO");

#endif

                PacketQueueReset(q);

        }

        //make a copy of the incoming packet

        if(av_dup_packet(pkt) < 0) {

#ifdef DEBUG_QUEUE

                printf("QUEUE: PUT in Queue cannot duplicate in packet        : NPackets=%d Type=%s\n",q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO");

#endif

                return -1;

        }

        pkt1 = av_malloc(sizeof(AVPacketList));

        if(!pkt1) {

                av_free_packet(pkt);

                return -1;

        }

        pkt1->pkt = *pkt;

        pkt1->next = NULL;

        static time_t last_auto_switch = 0;

        // file streaming loop detected => re-tune channel and start grabbing statistics

        if(

                (pkt->stream_index < last_video_frame_extracted)

                && (pkt->stream_index <= RESTART_FRAME_NUMBER_THRESHOLD)

                && ((time(NULL) - last_auto_switch) > 10)

        )

        {

                last_auto_switch = time(NULL);

                SDL_LockMutex(q->mutex);

                ReTune(&(Channels[SelectedChannel]));

                SDL_UnlockMutex(q->mutex);

        }

        else

        {

                SDL_LockMutex(q->mutex);

                // INSERTION SORT ALGORITHM

                // before inserting pkt, check if pkt.stream_index is <= current_extracted_frame.

                if(pkt->stream_index > q->last_frame_extracted)

                {

                        // either checking starting from the first_pkt or needed other struct like AVPacketList with next and prev....

                        //if (!q->last_pkt)

                        if(!q->first_pkt) {

                                q->first_pkt = pkt1;

                                q->last_pkt = pkt1;

                        }

                        else if(pkt->stream_index < q->first_pkt->pkt.stream_index) {

                                //the packet that has arrived is earlier than the first we got some time ago!

                                //we need to put it at the head of the queue

                                pkt1->next = q->first_pkt;

                                q->first_pkt = pkt1;

                        }

                        else {

                                tmp = q->first_pkt;

                                while(tmp->pkt.stream_index < pkt->stream_index) {

                                        prevtmp = tmp;

                                        tmp = tmp->next;

                                        if(!tmp) {

                                                break;

                                        }

                                }

                                if(tmp && tmp->pkt.stream_index == pkt->stream_index) {

                                        //we already have a frame with that index

                                        skip = 1;

#ifdef DEBUG_QUEUE

                                        printf("%s QUEUE: PUT: we already have frame with index %d, skipping\n", ((q->queueType == AUDIO) ? "AUDIO" : "VIDEO"), pkt->stream_index);

#endif

                                }

                                else {

                                        prevtmp->next = pkt1;

                                        pkt1->next = tmp;

                                        if(pkt1->next == NULL)

                                                q->last_pkt = pkt1;

                                }

                                //q->last_pkt->next = pkt1; // It was uncommented when not insertion sort

                        }

                        if(skip == 0) {

                                //q->last_pkt = pkt1;

                                q->nb_packets++;

                                q->size += pkt1->pkt.size;

                                if(q->nb_packets>=queue_filling_threshold && QueueFillingMode) // && q->queueType==AUDIO)

                                {

                                        QueueFillingMode=0;

#ifdef DEBUG_QUEUE

                                        printf("QUEUE: PUT: FillingMode set to zero\n");

#endif

                                }

                        }

                }

                else {

                        av_free_packet(&pkt1->pkt);

                        av_free(pkt1);

#ifdef DEBUG_QUEUE

                        printf("QUEUE: PUT: NOT inserting because index %d <= last extracted %d\n", pkt->stream_index, q->last_frame_extracted);

#endif

                        res = 1;

                }

                SDL_UnlockMutex(q->mutex);

        }

        return res;

}

int ChunkerPlayerCore_InitCodecs(int width, int height, int sample_rate, short int audio_channels)

{

        // some initializations

        QueueStopped = 0;

        AudioQueueOffset=0;

        AVPlaying = 0;

        GotSigInt = 0;

        FirstTimeAudio=1;

        FirstTime = 1;

        deltaAudioQError=0;

        InitRect = NULL;

        img_convert_ctx = NULL;

        SDL_AudioSpec wanted_spec;

        AVCodec         *aCodec;

        memset(&VideoCallbackThreadParams, 0, sizeof(ThreadVal));

        VideoCallbackThreadParams.width = width;

        VideoCallbackThreadParams.height = height;

        // Register all formats and codecs

        avcodec_init();

        av_register_all();

        aCodecCtx = avcodec_alloc_context();

        //aCodecCtx->bit_rate = 64000;

        aCodecCtx->sample_rate = sample_rate;

        aCodecCtx->channels = audio_channels;

#ifdef MP3_AUDIO_ENCODER

        aCodec = avcodec_find_decoder(CODEC_ID_MP3); // codec audio

#else

        aCodec = avcodec_find_decoder(CODEC_ID_MP2);

#endif

        printf("MP2 codec id %d MP3 codec id %d\n",CODEC_ID_MP2,CODEC_ID_MP3);

        if(!aCodec) {

                printf("Codec not found!\n");

                return -1;

        }

        if(avcodec_open(aCodecCtx, aCodec)<0) {

                fprintf(stderr, "could not open codec\n");

                return -1; // Could not open codec

        }

        printf("using audio Codecid: %d ",aCodecCtx->codec_id);

        printf("samplerate: %d ",aCodecCtx->sample_rate);

        printf("channels: %d\n",aCodecCtx->channels);

        CurrentAudioFreq = wanted_spec.freq = aCodecCtx->sample_rate;

        wanted_spec.format = AUDIO_S16SYS;

        wanted_spec.channels = aCodecCtx->channels;

        wanted_spec.silence = 0;

        CurrentAudioSamples = wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;

        wanted_spec.callback = AudioCallback;

        wanted_spec.userdata = aCodecCtx;

        if(SDL_OpenAudio(&wanted_spec,&AudioSpecification)<0)

        {

                fprintf(stderr,"SDL_OpenAudio: %s\n", SDL_GetError());

                return -1;

        }

        dimAudioQ = AudioSpecification.size;

        deltaAudioQ = (float)((float)AudioSpecification.samples)*1000/AudioSpecification.freq;

#ifdef DEBUG_AUDIO

        printf("freq:%d\n",AudioSpecification.freq);

        printf("format:%d\n",AudioSpecification.format);

        printf("channels:%d\n",AudioSpecification.channels);

        printf("silence:%d\n",AudioSpecification.silence);

        printf("samples:%d\n",AudioSpecification.samples);

        printf("size:%d\n",AudioSpecification.size);

        printf("deltaAudioQ: %f\n",deltaAudioQ);

#endif

        outbuf_audio = malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);

        //initialize the audio and the video queues

        PacketQueueInit(&audioq, AUDIO);

        PacketQueueInit(&videoq, VIDEO);

        // Init audio and video buffers

        av_init_packet(&AudioPkt);

        av_init_packet(&VideoPkt);

        //printf("AVCODEC_MAX_AUDIO_FRAME_SIZE=%d\n", AVCODEC_MAX_AUDIO_FRAME_SIZE);

        AudioPkt.data=(uint8_t *)malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);

        if(!AudioPkt.data) return 1;

        VideoPkt.data=(uint8_t *)malloc(width*height*3/2);

        if(!VideoPkt.data) return 1;

        InitRect = (SDL_Rect*) malloc(sizeof(SDL_Rect));

        if(!InitRect)

        {

                printf("Memory error!!!\n");

                return -1;

        }

        InitRect->x = OverlayRect.x;

        InitRect->y = OverlayRect.y;

        InitRect->w = OverlayRect.w;

        InitRect->h = OverlayRect.h;

        char audio_stats[255], video_stats[255];

        sprintf(audio_stats, "waiting for incoming audio packets...");

        sprintf(video_stats, "waiting for incoming video packets...");

        ChunkerPlayerGUI_SetStatsText(audio_stats, video_stats,LED_GREEN);

        return 0;

}

int DecodeEnqueuedAudio(AVPacket *pkt, PacketQueue *q, int* size)

{

        uint16_t *audio_bufQ = NULL;

        int16_t *dataQ = NULL;

        int data_sizeQ = AVCODEC_MAX_AUDIO_FRAME_SIZE;

        int lenQ;

        int ret = 0;

        //set the flag to decoded anyway        

        pkt->convergence_duration = -1;

        audio_bufQ = (uint16_t *)av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);

        if(audio_bufQ) {

#ifdef DEBUG_AUDIO_BUFFER

                printf("AUDIO_BUFFER: about to decode packet %d, size %d, data %d\n", pkt->stream_index, pkt->size, pkt->data);

#endif

                //decode the packet data

                lenQ = avcodec_decode_audio3(aCodecCtx, (int16_t *)audio_bufQ, &data_sizeQ, pkt);

                if(lenQ > 0) {

                        dataQ = (int16_t *)av_malloc(data_sizeQ); //this will be free later at the time of playback

                        if(dataQ) {

                                memcpy(dataQ, audio_bufQ, data_sizeQ);

                                if(pkt->data != NULL)

                                {

                                        //discard the old encoded bytes

                                        av_free(pkt->data);

                                }

                                //subtract them from queue size

                                q->size -= pkt->size;

                                *size = pkt->size;

                                pkt->data = (int8_t *)dataQ;

                                pkt->size = data_sizeQ;

                                //add new size to queue size

                                q->size += pkt->size;

                                ret = 1;

                        }

                        else {

#ifdef DEBUG_AUDIO_BUFFER

                                printf("AUDIO_BUFFER: cannot alloc space for decoded packet %d\n", pkt->stream_index);

#endif

                        }

                }

                else {

#ifdef DEBUG_AUDIO_BUFFER

                        printf("AUDIO_BUFFER: cannot decode packet %d\n", pkt->stream_index);

#endif

                }

                av_free(audio_bufQ);

        }

        else {

#ifdef DEBUG_AUDIO_BUFFER

                printf("AUDIO_BUFFER: cannot alloc decode buffer for packet %d\n", pkt->stream_index);

#endif

        }

        return ret; //problems occurred

}

/**

 * removes a packet from the list and returns the next

 * */

AVPacketList *RemoveFromQueue(PacketQueue *q, AVPacketList *p)

{

        AVPacketList *retpk = p->next;

        q->nb_packets--;

        //adjust size here and not in the various cases of the dequeue

        q->size -= p->pkt.size;

        if(&p->pkt)

        {

                av_free_packet(&p->pkt);

        }

        if(p)

                av_free(p);

        return retpk;

}

AVPacketList *SeekAndDecodePacketStartingFrom(AVPacketList *p, PacketQueue *q, int* size)

{

        while(p) {

                        //check if audio packet has been already decoded

                        if(p->pkt.convergence_duration == 0) {

                                //not decoded yet, try to decode it

                                if( !DecodeEnqueuedAudio(&(p->pkt), q, size) ) {

                                        //it was not possible to decode this packet, return next one

                                        p = RemoveFromQueue(q, p);

                                }

                                else

                                        return p;

                        }

                        else

                                return p;

        }

        return NULL;

}

int PacketQueueGet(PacketQueue *q, AVPacket *pkt, short int av, int* size)

{

        //AVPacket tmp;

        AVPacketList *pkt1 = NULL;

        int ret=-1;

        int SizeToCopy=0;

        struct timeval now_tv;

        SDL_LockMutex(q->mutex);

#ifdef DEBUG_QUEUE

        printf("QUEUE: Get NPackets=%d Type=%s\n", q->nb_packets, (q->queueType==AUDIO) ? "AUDIO" : "VIDEO");

#endif

        if((q->queueType==AUDIO && QueueFillingMode) || QueueStopped)

        {

                SDL_UnlockMutex(q->mutex);

                return -1;

        }

        if(av==1) { //somebody requested an audio packet, q is the audio queue

                //try to dequeue the first packet of the audio queue

                pkt1 = SeekAndDecodePacketStartingFrom(q->first_pkt, q, size);

                if(pkt1) { //yes we have them!

                        if(pkt1->pkt.size-AudioQueueOffset > dimAudioQ) {

                                //one packet is enough to give us the requested number of bytes by the audio_callback

#ifdef DEBUG_QUEUE_DEEP

                                printf("  AV=1 and Extract from the same packet\n");

#endif

                                pkt->size = dimAudioQ;

                                memcpy(pkt->data,pkt1->pkt.data+AudioQueueOffset,dimAudioQ);

                                pkt->dts = pkt1->pkt.dts;

                                pkt->pts = pkt1->pkt.pts;

                                pkt->stream_index = pkt1->pkt.stream_index;//1;

                                pkt->flags = 1;

                                pkt->pos = -1;

                                pkt->convergence_duration = -1;

#ifdef DEBUG_QUEUE_DEEP

                                printf("   Adjust timestamps Old = %lld New = %lld\n", pkt1->pkt.dts, (int64_t)(pkt1->pkt.dts + deltaAudioQ + deltaAudioQError));

#endif

                                int64_t Olddts=pkt1->pkt.dts;

                                pkt1->pkt.dts += deltaAudioQ + deltaAudioQError;

                                pkt1->pkt.pts += deltaAudioQ + deltaAudioQError;

                                deltaAudioQError=(float)Olddts + deltaAudioQ + deltaAudioQError - (float)pkt1->pkt.dts;

                                AudioQueueOffset += dimAudioQ;

#ifdef DEBUG_QUEUE_DEEP

                                printf("   deltaAudioQError = %f\n",deltaAudioQError);

#endif

                                ChunkerPlayerStats_UpdateAudioLossHistory(&(q->PacketHistory), pkt->stream_index, q->last_frame_extracted);

                                //update index of last frame extracted

                                q->last_frame_extracted = pkt->stream_index;

#ifdef DEBUG_AUDIO_BUFFER

                                printf("1: idx %d    \taqo %d    \tstc %d    \taqe %f    \tpsz %d\n", pkt1->pkt.stream_index, AudioQueueOffset, SizeToCopy, deltaAudioQError, pkt1->pkt.size);

#endif

                                ret = 1; //OK

                        }

                        else {

                                //we need bytes from two consecutive packets to satisfy the audio_callback

#ifdef DEBUG_QUEUE_DEEP

                                printf("  AV = 1 and Extract from 2 packets\n");

#endif

                                //check for a valid next packet since we will finish the current packet

                                //and also take some bytes from the next one

                                pkt1->next = SeekAndDecodePacketStartingFrom(pkt1->next, q, size);

                                if(pkt1->next) {

#ifdef DEBUG_QUEUE_DEEP

                                        printf("   we have a next...\n");

#endif

                                        pkt->size = dimAudioQ;

                                        pkt->dts = pkt1->pkt.dts;

                                        pkt->pts = pkt1->pkt.pts;

                                        pkt->stream_index = pkt1->pkt.stream_index;//1;

                                        pkt->flags = 1;

                                        pkt->pos = -1;

                                        pkt->convergence_duration = -1;

                                        {

                                                SizeToCopy=pkt1->pkt.size-AudioQueueOffset;

#ifdef DEBUG_QUEUE_DEEP

                                                printf("      SizeToCopy=%d\n",SizeToCopy);

#endif

                                                memcpy(pkt->data, pkt1->pkt.data+AudioQueueOffset, SizeToCopy);

                                                memcpy(pkt->data+SizeToCopy, pkt1->next->pkt.data, (dimAudioQ-SizeToCopy)*sizeof(uint8_t));

                                        }

#ifdef DEBUG_AUDIO_BUFFER

                                        printf("2: idx %d    \taqo %d    \tstc %d    \taqe %f    \tpsz %d\n", pkt1->pkt.stream_index, AudioQueueOffset, SizeToCopy, deltaAudioQError, pkt1->pkt.size);

#endif

                                }

#ifdef DEBUG_AUDIO_BUFFER

                                else {

                                        printf("2: NONEXT\n");

                                }

#endif

                                //HINT SEE before q->size -= SizeToCopy;

                                q->first_pkt = RemoveFromQueue(q, pkt1);

                                // Adjust timestamps

                                pkt1 = q->first_pkt;

                                if(pkt1) {

                                        int Offset=(dimAudioQ-SizeToCopy)*1000/(AudioSpecification.freq*2*AudioSpecification.channels);

                                        int64_t LastDts=pkt1->pkt.dts;

                                        pkt1->pkt.dts += Offset + deltaAudioQError;

                                        pkt1->pkt.pts += Offset + deltaAudioQError;

                                        deltaAudioQError = (float)LastDts + (float)Offset + deltaAudioQError - (float)pkt1->pkt.dts;

#ifdef DEBUG_QUEUE_DEEP

                                        printf("   Adjust timestamps Old = %lld New = %lld\n", LastDts, pkt1->pkt.dts);

#endif

                                        AudioQueueOffset = dimAudioQ - SizeToCopy;

                                        //SEE BEFORE HINT q->size -= AudioQueueOffset;

                                        ret = 1;

                                        ChunkerPlayerStats_UpdateAudioLossHistory(&(q->PacketHistory), pkt->stream_index, q->last_frame_extracted);

                                }

                                else {

                                        AudioQueueOffset=0;

                                }

#ifdef DEBUG_QUEUE_DEEP

                                printf("   deltaAudioQError = %f\n",deltaAudioQError);

#endif

                                //update index of last frame extracted

                                q->last_frame_extracted = pkt->stream_index;

                        }

                }

        }

        else { //somebody requested a video packet, q is the video queue

                pkt1 = q->first_pkt;

                if(pkt1) {

#ifdef DEBUG_QUEUE_DEEP

                        printf("  AV not 1\n");

#endif

                        pkt->size = pkt1->pkt.size;

                        pkt->dts = pkt1->pkt.dts;

                        pkt->pts = pkt1->pkt.pts;

                        pkt->stream_index = pkt1->pkt.stream_index;

                        pkt->flags = pkt1->pkt.flags;

                        pkt->pos = pkt1->pkt.pos;

                        pkt->convergence_duration = pkt1->pkt.convergence_duration;

                        //*pkt = pkt1->pkt;

                        if((pkt->data != NULL) && (pkt1->pkt.data != NULL))

                                memcpy(pkt->data, pkt1->pkt.data, pkt1->pkt.size);

                        //HINT SEE BEFORE q->size -= pkt1->pkt.size;

                        q->first_pkt = RemoveFromQueue(q, pkt1);

                        ret = 1;

                        ChunkerPlayerStats_UpdateVideoLossHistory(&(q->PacketHistory), pkt->stream_index, q->last_frame_extracted);

                        //update index of last frame extracted

                        q->last_frame_extracted = pkt->stream_index;

                        last_video_frame_extracted = q->last_frame_extracted;

                }

#ifdef DEBUG_QUEUE

                else {

                        printf("  VIDEO pk1 NULL!!!!\n");

                }

#endif

        }

        if(q->nb_packets==0 && q->queueType==AUDIO) {

                QueueFillingMode=1;

#ifdef DEBUG_QUEUE

                printf("QUEUE: Get FillingMode ON\n");

#endif

        }

#ifdef DEBUG_QUEUE

        printf("QUEUE: Get Last %s Frame Extracted = %d\n", (q->queueType==AUDIO) ? "AUDIO" : "VIDEO", q->last_frame_extracted);

#endif

        SDL_UnlockMutex(q->mutex);

        return ret;

}

int AudioDecodeFrame(uint8_t *audio_buf, int buf_size) {

        //struct timeval now;

        int audio_pkt_size = 0;

        int compressed_size = 0;

        long long Now;

        short int DecodeAudio=0, SkipAudio=0;

        //int len1, data_size;

        //gettimeofday(&now,NULL);

        //Now = (now.tv_sec)*1000+now.tv_usec/1000;

        Now=(long long)SDL_GetTicks();

        struct timeval now_tv;

        if(QueueFillingMode || QueueStopped)

        {

                //SDL_LockMutex(timing_mutex);

                FirstTimeAudio=1;

                FirstTime = 1;

                //SDL_UnlockMutex(timing_mutex);

                return -1;

        }

        if((FirstTime==1 || FirstTimeAudio==1) && audioq.size>0) {

                if(audioq.first_pkt->pkt.pts>0)

                {

                        //SDL_LockMutex(timing_mutex);

                        DeltaTime=Now-(long long)(audioq.first_pkt->pkt.pts);

                        FirstTimeAudio = 0;

                        FirstTime = 0;

                        //SDL_UnlockMutex(timing_mutex);

#ifdef DEBUG_AUDIO 

                         printf("AUDIO: audio_decode_frame - DeltaTimeAudio=%lld\n",DeltaTime);

#endif

                }

        }

#ifdef DEBUG_AUDIO 

        if(audioq.first_pkt)

        {

                printf("AUDIO: audio_decode_frame - Syncro params: Delta:%lld Now:%lld pts=%lld pts+Delta=%lld ",(long long)DeltaTime,Now,(long long)audioq.first_pkt->pkt.pts,(long long)audioq.first_pkt->pkt.pts+DeltaTime);

                printf("AUDIO: QueueLen=%d ",(int)audioq.nb_packets);

                printf("AUDIO: QueueSize=%d\n",(int)audioq.size);

        }

        else

                printf("AUDIO: audio_decode_frame - Empty queue\n");

#endif

        gettimeofday(&now_tv, NULL);

        if(audioq.nb_packets>0)

        {

                if((long long)audioq.first_pkt->pkt.pts+DeltaTime<Now-(long long)MAX_TOLLERANCE)

                {

                        SkipAudio = 1;

                        DecodeAudio = 0;

                }

                else if((long long)audioq.first_pkt->pkt.pts+DeltaTime>=Now-(long long)MAX_TOLLERANCE &&

                        (long long)audioq.first_pkt->pkt.pts+DeltaTime<=Now+(long long)MAX_TOLLERANCE) {

                                SkipAudio = 0;

                                DecodeAudio = 1;

                }

        }

        while(SkipAudio==1 && audioq.size>0)

        {

                SkipAudio = 0;

#ifdef DEBUG_AUDIO

                 printf("AUDIO: skipaudio: queue size=%d\n",audioq.size);

#endif

                if(PacketQueueGet(&audioq,&AudioPkt,1, &compressed_size) < 0) {

                        return -1;

                }

                if(audioq.first_pkt)

                {

                        ChunkerPlayerStats_UpdateAudioSkipHistory(&(audioq.PacketHistory), AudioPkt.stream_index, compressed_size);

                        if((long long)audioq.first_pkt->pkt.pts+DeltaTime<Now-(long long)MAX_TOLLERANCE)

                        {

                                SkipAudio = 1;

                                DecodeAudio = 0;

                        }

                        else if((long long)audioq.first_pkt->pkt.pts+DeltaTime>=Now-(long long)MAX_TOLLERANCE &&

                                (long long)audioq.first_pkt->pkt.pts+DeltaTime<=Now+(long long)MAX_TOLLERANCE) {

                                        SkipAudio = 0;

                                        DecodeAudio = 1;

                        }

                }

        }

        if(DecodeAudio==1) {

                if(PacketQueueGet(&audioq,&AudioPkt,1, &compressed_size) < 0) {

                        return -1;

                }

                memcpy(audio_buf,AudioPkt.data,AudioPkt.size);

                audio_pkt_size = AudioPkt.size;

#ifdef DEBUG_AUDIO

                 printf("AUDIO: Decode audio\n");

#endif

                ChunkerPlayerStats_UpdateAudioPlayedHistory(&(audioq.PacketHistory), AudioPkt.stream_index, compressed_size);

        }

        return audio_pkt_size;

}

int VideoCallback(void *valthread)

{

        //AVPacket pktvideo;

        AVCodecContext  *pCodecCtx;

        AVCodec         *pCodec;

        AVFrame         *pFrame;

        int frameFinished;

        AVPicture pict;

        long long Now;

        short int SkipVideo, DecodeVideo;

#ifdef SAVE_YUV

        static AVFrame* lastSavedFrameBuffer = NULL;

        if(!lastSavedFrameBuffer)

                lastSavedFrameBuffer = (AVFrame*) malloc(sizeof(AVFrame));

#endif

        //double frame_rate = 0.0,time_between_frames=0.0;

        //struct timeval now;

        //int wait_for_sync = 1;

        ThreadVal *tval;

        tval = (ThreadVal *)valthread;

        //frame_rate = tval->framerate;

        //time_between_frames = 1.e6 / frame_rate;

        //gettimeofday(&time_now,0);

        //frecon = fopen("recondechunk.mpg","wb");

        pCodecCtx=avcodec_alloc_context();

        pCodecCtx->codec_type = CODEC_TYPE_VIDEO;

        //pCodecCtx->debug = FF_DEBUG_DCT_COEFF;

#ifdef H264_VIDEO_ENCODER

        pCodecCtx->codec_id  = CODEC_ID_H264;

        pCodecCtx->me_range = 16;

        pCodecCtx->max_qdiff = 4;

        pCodecCtx->qmin = 1;

        pCodecCtx->qmax = 30;

        pCodecCtx->qcompress = 0.6;

#else

        pCodecCtx->codec_id  = CODEC_ID_MPEG4;

#endif

        //pCodecCtx->bit_rate = 400000;

        // resolution must be a multiple of two

        pCodecCtx->width = tval->width;//176;//352;

        pCodecCtx->height = tval->height;//144;//288;

        // frames per second

        //pCodecCtx->time_base = (AVRational){1,25};

        //pCodecCtx->gop_size = 10; // emit one intra frame every ten frames

        //pCodecCtx->max_b_frames=1;

        pCodecCtx->pix_fmt = PIX_FMT_YUV420P;

        pCodec=avcodec_find_decoder(pCodecCtx->codec_id);

        if(pCodec==NULL) {

                fprintf(stderr, "Unsupported codec!\n");

                return -1; // Codec not found

        }

        if(avcodec_open(pCodecCtx, pCodec) < 0) {

                fprintf(stderr, "could not open codec\n");

                return -1; // Could not open codec

        }

        pFrame=avcodec_alloc_frame();

        if(pFrame==NULL) {

                printf("Memory error!!!\n");

                return -1;

        }

#ifdef DEBUG_VIDEO

         printf("VIDEO: video_callback entering main cycle\n");

#endif

        struct timeval now_tv;

        while(AVPlaying && !quit) {

                if(QueueFillingMode || QueueStopped)

                {

                        //SDL_LockMutex(timing_mutex);

                        FirstTime = 1;

                        //SDL_UnlockMutex(timing_mutex);

                        usleep(5000);

                        continue;

                }

                DecodeVideo = 0;

                SkipVideo = 0;

                Now=(long long)SDL_GetTicks();

                if(FirstTime==1 && videoq.size>0) {

                        if(videoq.first_pkt->pkt.pts>0)

                        {

                                //SDL_LockMutex(timing_mutex);

                                DeltaTime=Now-(long long)videoq.first_pkt->pkt.pts;

                                FirstTime = 0;

                                //SDL_UnlockMutex(timing_mutex);

                        }

#ifdef DEBUG_VIDEO 

                         printf("VIDEO: VideoCallback - DeltaTimeAudio=%lld\n",DeltaTime);

#endif

                }

#ifdef DEBUG_VIDEO 

                if(videoq.first_pkt)

                {

                        printf("VIDEO: VideoCallback - Syncro params: Delta:%lld Now:%lld pts=%lld pts+Delta=%lld ",(long long)DeltaTime,Now,(long long)videoq.first_pkt->pkt.pts,(long long)videoq.first_pkt->pkt.pts+DeltaTime);

                        printf("VIDEO: Index=%d ", (int)videoq.first_pkt->pkt.stream_index);

                        printf("VIDEO: QueueLen=%d ", (int)videoq.nb_packets);

                        printf("VIDEO: QueueSize=%d\n", (int)videoq.size);

                }

                else

                        printf("VIDEO: VideoCallback - Empty queue\n");

#endif

                if(videoq.nb_packets>0) {

                        if(((long long)videoq.first_pkt->pkt.pts+DeltaTime)<Now-(long long)MAX_TOLLERANCE)

                        {

                                SkipVideo = 1;

                                DecodeVideo = 0;

                        }

                        else 

                                if(((long long)videoq.first_pkt->pkt.pts+DeltaTime)>=Now-(long long)MAX_TOLLERANCE &&

                                   ((long long)videoq.first_pkt->pkt.pts+DeltaTime)<=Now+(long long)MAX_TOLLERANCE) {

                                        SkipVideo = 0;

                                        DecodeVideo = 1;

                                }

                                // else (i.e. videoq.first_pkt->pkt.pts+DeltaTime>Now+MAX_TOLLERANCE)

                                // do nothing and continue

                }

#ifdef DEBUG_VIDEO

                printf("VIDEO: skipvideo:%d decodevideo:%d\n",SkipVideo,DecodeVideo);

#endif

                gettimeofday(&now_tv, NULL);

                while(SkipVideo==1 && videoq.size>0)

                {

                        SkipVideo = 0;

#ifdef DEBUG_VIDEO 

                         printf("VIDEO: Skip Video\n");

#endif

                        if(PacketQueueGet(&videoq,&VideoPkt,0, NULL) < 0) {

                                break;

                        }

                        avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &VideoPkt);

                        // sometimes assertion fails, maybe the decoder change the frame type

                        //~ if(LastSourceIFrameDistance == 0)

                                //~ assert(pFrame->pict_type == 1);

                        if(videoq.first_pkt)

                        {

                                if((long long)videoq.first_pkt->pkt.pts+DeltaTime<Now-(long long)MAX_TOLLERANCE)

                                {

                                        SkipVideo = 1;

                                        DecodeVideo = 0;

                                }

                                else if((long long)videoq.first_pkt->pkt.pts+DeltaTime>=Now-(long long)MAX_TOLLERANCE &&

                                                                (long long)videoq.first_pkt->pkt.pts+DeltaTime<=Now+(long long)MAX_TOLLERANCE) {

                                        SkipVideo = 0;

                                        DecodeVideo = 1;

                                }

                        }

                        ChunkerPlayerStats_UpdateVideoSkipHistory(&(videoq.PacketHistory), VideoPkt.stream_index, pFrame->pict_type, VideoPkt.size, pFrame);

                        /*if(pFrame->pict_type == 1)

                        {

                                int i1;

                                // every 23 items (23 is the qstride field in the AVFrame struct) there is 1 zero.

                                // 396/23 = 17 => 396 macroblocks + 17 zeros = 413 items

                                for(i1=0; i1< 413; i1++)

                                        fprintf(qscaletable_file, "%d\t", (int)pFrame->qscale_table[i1]);

                                fprintf(qscaletable_file, "\n");

                        }*/

                        //ChunkerPlayerStats_UpdateVideoPlayedHistory(&(videoq.PacketHistory), VideoPkt.stream_index, pFrame->pict_type, VideoPkt.size);

                }

                if(DecodeVideo==1) {

                        if(PacketQueueGet(&videoq,&VideoPkt,0, NULL) > 0) {

                                avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &VideoPkt);

                                if(frameFinished)

                                { // it must be true all the time else error

#ifdef DEBUG_VIDEO

                                        printf("VIDEO: FrameFinished\n");

#endif

                                        decoded_vframes++;

                                        // sometimes assertion fails, maybe the decoder change the frame type

                                        //~ if(LastSourceIFrameDistance == 0)

                                                //~ assert(pFrame->pict_type == 1);

#ifdef SAVE_YUV

                                        if(LastSavedVFrame == -1)

                                        {

                                                memcpy(lastSavedFrameBuffer, pFrame, sizeof(AVFrame));

                                                SaveFrame(pFrame, pCodecCtx->width, pCodecCtx->height);

                                                LastSavedVFrame = VideoPkt.stream_index;

                                        }

                                        else if(LastSavedVFrame == (VideoPkt.stream_index-1))

                                        {

                                                memcpy(lastSavedFrameBuffer, pFrame, sizeof(AVFrame));

                                                SaveFrame(pFrame, pCodecCtx->width, pCodecCtx->height);

                                                LastSavedVFrame = VideoPkt.stream_index;

                                        }

                                        else if(LastSavedVFrame >= 0)

                                        {

                                                while(LastSavedVFrame < (VideoPkt.stream_index-1))

                                                {

                                                        SaveFrame(lastSavedFrameBuffer, pCodecCtx->width, pCodecCtx->height);

                                                }

                                                memcpy(lastSavedFrameBuffer, pFrame, sizeof(AVFrame));

                                                SaveFrame(pFrame, pCodecCtx->width, pCodecCtx->height);

                                                LastSavedVFrame = VideoPkt.stream_index;

                                        }

#endif

                                        ChunkerPlayerStats_UpdateVideoPlayedHistory(&(videoq.PacketHistory), VideoPkt.stream_index, pFrame->pict_type, VideoPkt.size, pFrame);

                                        if(SilentMode)

                                                continue;

                                        // Lock SDL_yuv_overlay

                                        if(SDL_MUSTLOCK(MainScreen)) {

                                                if(SDL_LockSurface(MainScreen) < 0) {

                                                        continue;

                                                }

                                        }

                                        if(SDL_LockYUVOverlay(YUVOverlay) < 0) {

                                                if(SDL_MUSTLOCK(MainScreen)) {

                                                        SDL_UnlockSurface(MainScreen);

                                                }

                                                continue;

                                        }

                                        pict.data[0] = YUVOverlay->pixels[0];

                                        pict.data[1] = YUVOverlay->pixels[2];

                                        pict.data[2] = YUVOverlay->pixels[1];

                                        pict.linesize[0] = YUVOverlay->pitches[0];

                                        pict.linesize[1] = YUVOverlay->pitches[2];

                                        pict.linesize[2] = YUVOverlay->pitches[1];

                                        if(img_convert_ctx == NULL) {

                                                img_convert_ctx = sws_getContext(tval->width, tval->height, PIX_FMT_YUV420P, InitRect->w, InitRect->h, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

                                                if(img_convert_ctx == NULL) {

                                                        fprintf(stderr, "Cannot initialize the conversion context!\n");

                                                        exit(1);

                                                }

                                        }

#ifdef VIDEO_DEINTERLACE

                                        avpicture_deinterlace(

                                                (AVPicture*) pFrame,

                                                (const AVPicture*) pFrame,

                                                pCodecCtx->pix_fmt,

                                                tval->width, tval->height);

#endif

                                        // let's draw the data (*yuv[3]) on a SDL screen (*screen)

                                        sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0, tval->height, pict.data, pict.linesize);

                                        SDL_UnlockYUVOverlay(YUVOverlay);

                                        // Show, baby, show!

                                        SDL_LockMutex(OverlayMutex);

                                        SDL_DisplayYUVOverlay(YUVOverlay, &OverlayRect);

                                        SDL_UnlockMutex(OverlayMutex);

                                        //redisplay logo

                                        /**SDL_BlitSurface(image, NULL, MainScreen, &dest);*/

                                        /* Update the screen area just changed */

                                        /**SDL_UpdateRects(MainScreen, 1, &dest);*/

                                        if(SDL_MUSTLOCK(MainScreen)) {

                                                SDL_UnlockSurface(MainScreen);

                                        }

                                } //if FrameFinished

                                else

                                {

                                        ChunkerPlayerStats_UpdateVideoLossHistory(&(videoq.PacketHistory), VideoPkt.stream_index+1, videoq.last_frame_extracted-1);

                                }

                        } // if packet_queue_get

                } //if DecodeVideo=1

                usleep(5000);

        }

        avcodec_close(pCodecCtx);

        av_free(pCodecCtx);

        av_free(pFrame);

        //fclose(frecon);

#ifdef DEBUG_VIDEO

         printf("VIDEO: video callback end\n");

#endif

#ifdef SAVE_YUV

        if(!lastSavedFrameBuffer)

                free(lastSavedFrameBuffer);

        lastSavedFrameBuffer = NULL;

#endif

        return 0;

}

void AudioCallback(void *userdata, Uint8 *stream, int len)

{

        //AVCodecContext *aCodecCtx = (AVCodecContext *)userdata;

        int audio_size;

        static uint8_t audio_buf[AVCODEC_MAX_AUDIO_FRAME_SIZE];

        audio_size = AudioDecodeFrame(audio_buf, sizeof(audio_buf));

        if(SilentMode < 2)

                if(audio_size != len) {

                        memset(stream, 0, len);

                } else {

                        memcpy(stream, (uint8_t *)audio_buf, len);

                }

}

void SaveFrame(AVFrame *pFrame, int width, int height)

{

        FILE *pFile;

        int  y;

         // Open file

        pFile=fopen(YUVFileName, "ab");

        if(pFile==NULL)

                return;

        // Write header

        //fprintf(pFile, "P5\n%d %d\n255\n", width, height);

        // Write Y data

        for(y=0; y<height; y++)

                  fwrite(pFrame->data[0]+y*pFrame->linesize[0], 1, width, pFile);

        // Write U data

        for(y=0; y<height/2; y++)

                  fwrite(pFrame->data[1]+y*pFrame->linesize[1], 1, width/2, pFile);

        // Write V data

        for(y=0; y<height/2; y++)

                  fwrite(pFrame->data[2]+y*pFrame->linesize[2], 1, width/2, pFile);

        // Close file

        fclose(pFile);

}

int ChunkerPlayerCore_IsRunning()

{

        return AVPlaying;

}

void ChunkerPlayerCore_Play()

{

        if(AVPlaying) return;

        AVPlaying = 1;

        SDL_PauseAudio(0);

        video_thread = SDL_CreateThread(VideoCallback, &VideoCallbackThreadParams);

        ChunkerPlayerStats_Init();

        stats_thread = SDL_CreateThread(CollectStatisticsThread, NULL);

        decoded_vframes = 0;

        LastSavedVFrame = -1;

}

void ChunkerPlayerCore_Stop()

{

        if(!AVPlaying) return;

        AVPlaying = 0;

        // Stop audio&video playback

        SDL_WaitThread(video_thread, NULL);

        SDL_WaitThread(stats_thread, NULL);

        SDL_PauseAudio(1);        

        SDL_CloseAudio();

        if(YUVOverlay != NULL)

        {

                SDL_FreeYUVOverlay(YUVOverlay);

                YUVOverlay = NULL;

        }

        PacketQueueReset(&audioq);

        PacketQueueReset(&videoq);

        avcodec_close(aCodecCtx);

        av_free(aCodecCtx);

        free(AudioPkt.data);

        free(VideoPkt.data);

        free(outbuf_audio);

        free(InitRect);

        /*

        * Sleep two buffers' worth of audio before closing, in order

        *  to allow the playback to finish. This isn't always enough;

        *   perhaps SDL needs a way to explicitly wait for device drain?

        */

        int delay = 2 * 1000 * CurrentAudioSamples / CurrentAudioFreq;

        // printf("SDL_Delay(%d)\n", delay*10);

        SDL_Delay(delay*10);

}

void ChunkerPlayerCore_Pause()

{

        if(!AVPlaying) return;

        AVPlaying = 0;

        // Stop audio&video playback

        SDL_WaitThread(video_thread, NULL);

        SDL_PauseAudio(1);

        PacketQueueReset(&audioq);

        PacketQueueReset(&videoq);

}

int ChunkerPlayerCore_AudioEnded()

{

        return (audioq.nb_packets==0 && audioq.last_frame_extracted>0);

}

void ChunkerPlayerCore_ResetAVQueues()

{

#ifdef DEBUG_QUEUE

        printf("QUEUE: MAIN SHOULD RESET\n");

#endif

        PacketQueueReset(&audioq);

        PacketQueueReset(&videoq);

}

int ChunkerPlayerCore_EnqueueBlocks(const uint8_t *block, const int block_size)

{

#ifdef EMULATE_CHUNK_LOSS

        static time_t loss_cycle_start_time = 0, now = 0;

        static int early_losses = 0;

        static int clp_frames = 0;

        if(ScheduledChunkLosses)

        {

                static unsigned int random_threshold;

                now=time(NULL);

                if(!loss_cycle_start_time)

                        loss_cycle_start_time = now;

                if(((now-loss_cycle_start_time) >= ScheduledChunkLosses[((CurrChunkLossIndex+1)%NScheduledChunkLosses)].Time) && (NScheduledChunkLosses>1 || CurrChunkLossIndex==-1))

                {

                        CurrChunkLossIndex = ((CurrChunkLossIndex+1)%NScheduledChunkLosses);

                        if(CurrChunkLossIndex == (NScheduledChunkLosses-1))

                                loss_cycle_start_time = now;

                        if(ScheduledChunkLosses[CurrChunkLossIndex].Value == -1)

                                random_threshold = ScheduledChunkLosses[CurrChunkLossIndex].MinValue + (rand() % (ScheduledChunkLosses[CurrChunkLossIndex].MaxValue-ScheduledChunkLosses[CurrChunkLossIndex].MinValue));

                        else

                                random_threshold = ScheduledChunkLosses[CurrChunkLossIndex].Value;

                        printf("new ScheduledChunkLoss, time: %d, value: %d\n", (int)ScheduledChunkLosses[CurrChunkLossIndex].Time, random_threshold);

                }

                if(clp_frames > 0)

                {

                        clp_frames--;

                        return PLAYER_FAIL_RETURN;

                }

                if((rand() % 100) < random_threshold)

                {

                        if(early_losses > 0)

                early_losses--;

            else

            {

                clp_frames=early_losses=(ScheduledChunkLosses[CurrChunkLossIndex].Burstiness-1);

                return PLAYER_FAIL_RETURN;

            }

                }

        }

#endif

        Chunk *gchunk = NULL;

        int decoded_size = -1;

        uint8_t *tempdata, *buffer;

        int j;

        Frame *frame = NULL;

        AVPacket packet, packetaudio;

        uint16_t *audio_bufQ = NULL;

        //the frame.h gets encoded into 5 slots of 32bits (3 ints plus 2 more for the timeval struct

        static int sizeFrameHeader = 5*sizeof(int32_t);

        static int ExternalChunk_header_size = 5*CHUNK_TRANSCODING_INT_SIZE + 2*CHUNK_TRANSCODING_INT_SIZE + 2*CHUNK_TRANSCODING_INT_SIZE + 1*CHUNK_TRANSCODING_INT_SIZE*2;

        static int chunks_out_of_order = 0;

        static int last_chunk_id = -1;

        audio_bufQ = (uint16_t *)av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);

        if(!audio_bufQ) {

                printf("Memory error in audio_bufQ!\n");

                return PLAYER_FAIL_RETURN;

        }

        gchunk = (Chunk *)malloc(sizeof(Chunk));

        if(!gchunk) {

                printf("Memory error in gchunk!\n");

                av_free(audio_bufQ);

                return PLAYER_FAIL_RETURN;

        }

        decoded_size = decodeChunk(gchunk, block, block_size);

        if(last_chunk_id == -1)

                last_chunk_id = gchunk->id;

        if(gchunk->id > (last_chunk_id+1)) {

                chunks_out_of_order += gchunk->id - last_chunk_id - 1;

        }

        last_chunk_id = gchunk->id;

#ifdef DEBUG_CHUNKER

        printf("CHUNKER: enqueueBlock: id %d decoded_size %d target size %d - out_of_order %d\n", gchunk->id, decoded_size, GRAPES_ENCODED_CHUNK_HEADER_SIZE + ExternalChunk_header_size + gchunk->size, chunks_out_of_order);

#endif

  if(decoded_size < 0) {

                //HINT here i should differentiate between various return values of the decode

                //in order to free what has been allocated there

                printf("chunk probably corrupted!\n");

                av_free(audio_bufQ);

                free(gchunk);

                return PLAYER_FAIL_RETURN;

        }

        frame = (Frame *)malloc(sizeof(Frame));

        if(!frame) {

                printf("Memory error in Frame!\n");

                if(gchunk) {

                        if(gchunk->attributes) {

                                free(gchunk->attributes);

                        }

                        free(gchunk);

                }

                av_free(audio_bufQ);

                return PLAYER_FAIL_RETURN;

        }

        tempdata = gchunk->data; //let it point to first frame of payload

        j=gchunk->size;

        while(j>0 && !quit) {

                frame->number = bit32_encoded_pull(tempdata);

                tempdata += CHUNK_TRANSCODING_INT_SIZE;

                frame->timestamp.tv_sec = bit32_encoded_pull(tempdata);

                tempdata += CHUNK_TRANSCODING_INT_SIZE;

                frame->timestamp.tv_usec = bit32_encoded_pull(tempdata);

                tempdata += CHUNK_TRANSCODING_INT_SIZE;

                frame->size = bit32_encoded_pull(tempdata);

                tempdata += CHUNK_TRANSCODING_INT_SIZE;

                frame->type = bit32_encoded_pull(tempdata);

                tempdata += CHUNK_TRANSCODING_INT_SIZE;

                buffer = tempdata; // here coded frame information

                tempdata += frame->size; //let it point to the next frame

                if(frame->type < 5) { // video frame

                        av_init_packet(&packet);

                        packet.data = buffer;//video_bufQ;

                        packet.size = frame->size;

                        packet.pts = frame->timestamp.tv_sec*(unsigned long long)1000+frame->timestamp.tv_usec;

                        packet.dts = frame->timestamp.tv_sec*(unsigned long long)1000+frame->timestamp.tv_usec;

                        packet.stream_index = frame->number; // use of stream_index for number frame

                        //packet.duration = frame->timestamp.tv_sec;

                        if(packet.size > 0)