Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

#include "../winlib/winlib.h"

#include "fplay.h"

AVCodecContext  *pCodecCtx;

AVCodecContext  *aCodecCtx;

AVCodec         *pCodec;

AVCodec         *aCodec;

AVFrame         *pFrame;

int             videoStream;

int             audioStream;

extern int sample_rate;

char *movie_file;

queue_t  q_audio;

int64_t  rewind_pos;

{

{

    int i;

        printf("Please provide a movie file\n");

        return -1;

    }

    /* register all codecs, demux and protocols */

    avdevice_register_all();

    av_register_all();

    {

        printf("Cannot open file %s\n\r", argv[1]);

        return -1; // Couldn't open file

    };

    if(avformat_find_stream_info(pFormatCtx, NULL)<0)

    {

        printf("Cannot find streams\n\r");

        return -1;

    };

    stream_duration = pFormatCtx->duration;

   // Find the first video stream

    videoStream=-1;

    audioStream=-1;

    for(i=0; i < pFormatCtx->nb_streams; i++)

    {

//        pFormatCtx->streams[i]->discard = AVDISCARD_ALL;

            && videoStream < 0)

        {

            videoStream=i;

            video_time_base = pFormatCtx->streams[i]->time_base;

            if(stream_duration == 0)

//                stream_duration = 1000.0 *

//                              pFormatCtx->streams[i]->duration *

//                              av_q2d(pFormatCtx->streams[i]->time_base);

               stream_duration = pFormatCtx->streams[i]->duration;

        if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO &&

            audioStream < 0)

        {

            audioStream=i;

            if(stream_duration == 0)

//                stream_duration = 1000.0 *

//                              pFormatCtx->streams[i]->duration *

//                              av_q2d(pFormatCtx->streams[i]->time_base);

               stream_duration = pFormatCtx->streams[i]->duration;

    }

    {

        printf("Video stream not detected\n\r");

        return -1; // Didn't find a video stream

    }

    pCodecCtx=pFormatCtx->streams[videoStream]->codec;

    aCodecCtx=pFormatCtx->streams[audioStream]->codec;

    pCodec=avcodec_find_decoder(pCodecCtx->codec_id);

    if(pCodec==NULL) {

        printf("Unsupported codec with id %d for input stream %d\n",

        pCodecCtx->codec_id, videoStream);

        return -1; // Codec not found

    }

    {

        printf("Error while opening codec for input stream %d\n",

                videoStream);

        return -1; // Could not open codec

    };

            aCodecCtx->request_channels = FFMIN(2, aCodecCtx->channels);

    else

            aCodecCtx->request_channels = 2;

    {

        if(avcodec_open2(aCodecCtx, aCodec, NULL) >= 0 )

        {

            WAVEHEADER       whdr;

            int fmt;

            aCodecCtx->sample_rate, aCodecCtx->channels);

            whdr.riff_format = 0x45564157;

            whdr.wFormatTag = 0x01;

            whdr.nSamplesPerSec = aCodecCtx->sample_rate;

            whdr.nChannels = aCodecCtx->channels;

            whdr.wBitsPerSample = 16;

            {

                decoder_buffer = (uint8_t*)av_mallocz(AVCODEC_MAX_AUDIO_FRAME_SIZE*2+64);

                if( decoder_buffer != NULL )

                {

                    astream.lock   = 0;

                    astream.count  = 0;

                    astream.buffer = (char *)av_mallocz(AVCODEC_MAX_AUDIO_FRAME_SIZE*8);

                    if( astream.buffer != NULL )

                        have_sound = 1;

                    else

                        av_free(decoder_buffer);

                }

                if( have_sound == 0)

                {

                        printf("Not enough memory for audio buffers\n");

                }

            }

        }

        else printf("Cannot open audio codec\n\r");

    }

    else printf("Unsupported audio codec!\n");

        return 0;

    av_free(pFrame);

 // avcodec_close(pCodecCtx);

 // av_close_input_file(pFormatCtx);

}

{

    int eof = 0;

    AVPacket  packet;

    {

        int err;

        {

            err = av_read_frame(pFormatCtx, &packet);

            if( err < 0)

            {

                eof = 1;

                if (err != AVERROR_EOF)

                    printf("av_read_frame: error %x\n", err);

                break;

            }

            if(packet.stream_index==videoStream)

            {

                put_packet(&q_video, &packet);

            }

            else if( (packet.stream_index == audioStream) &&

                 (have_sound != 0) )

            {

                put_packet(&q_audio, &packet);

                if(audio_base == -1.0)

                {

                    if (packet.dts != AV_NOPTS_VALUE)

                        audio_base = get_audio_base() * packet.dts;

//                    printf("audio base %f\n", audio_base);

                };

            }

            else

            {

                av_free_packet(&packet);

            };

        }

        else break;

    };

{

    int       eof;

    AVPacket  packet;

    int       ret;

    {

        int err;

        {

            delay(1);

            continue;

        };

        {

 //           int64_t timestamp = 0;

 //           int stream_index = av_find_default_stream_index(pFormatCtx);

                rewind_pos += pFormatCtx->start_time;

                                     rewind_pos, INT64_MAX, 0);

//            ret = avformat_seek_file(pFormatCtx, -1, 0,

//                                 0, INT64_MAX, 0);

//            __asm__ __volatile__("int3");

            {

                printf("could not seek to position %f\n",

                        (double)rewind_pos / AV_TIME_BASE);

            }

            else

            {

                avcodec_flush_buffers(pCodecCtx);

                avcodec_flush_buffers(aCodecCtx);

                    av_free_packet(&packet);

                    av_free_packet(&packet);

                audio_base = -1.0;

            };

            yield();

            printf("restart\n");

            continue;

        };

        {

            err = av_read_frame(pFormatCtx, &packet);

            if( err < 0)

            {

                eof = 1;

                if (err != AVERROR_EOF)

                    printf("av_read_frame: error %x\n", err);

                continue;

            }

            if(packet.stream_index==videoStream)

            {

                put_packet(&q_video, &packet);

            }

            else if( (packet.stream_index == audioStream) &&

                 (have_sound != 0) )

            {

                put_packet(&q_audio, &packet);

            }

            else

            {

                av_free_packet(&packet);

            };

            decode_video(pCodecCtx, &q_video);

            decode_audio(aCodecCtx, &q_audio);

            continue;

        };

        decode_video(pCodecCtx, &q_video);

        decode_audio(aCodecCtx, &q_audio);

        delay(1);

    };

    {

        ret =  decode_video(pCodecCtx, &q_video);

        ret |= decode_audio(aCodecCtx, &q_audio);

        delay(1);

    };

    delay(50);

    player_state = CLOSED;

    delay(300);

};

>