Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

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

#include "fplay.h"

volatile enum player_state decoder_state = PREPARE;

volatile enum player_state sound_state   = STOP;

AVCodecContext  *pCodecCtx;

AVCodecContext  *aCodecCtx;

AVCodec         *pCodec;

AVCodec         *aCodec;

AVFrame         *pFrame;

int             videoStream;

int             audioStream;

extern int resampler_size;

char *movie_file;

queue_t  q_audio;

int64_t  rewind_pos;

{

{

    int i;

    char *file_name, *dot;

     {

        movie_file = get_moviefile();

        if(movie_file == NULL)

        {

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

        return -1;

    }

    }

    else movie_file = argv[1];

    /* register all codecs, demux and protocols */

    avdevice_register_all();

    av_register_all();

    {

        printf("Cannot open file %s\n\r", movie_file);

        return -1; // Couldn't open file

    };

    if(avformat_find_stream_info(pFormatCtx, NULL)<0)

    {

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

        return -1;

    };

    dot = strrchr(file_name,'.');

    if(dot)

    {

        movie_file = malloc(dot-file_name+1);

        memcpy(movie_file, file_name, dot-file_name);

        movie_file[dot-file_name] = 0;

    }

    else movie_file = file_name;

    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);

}

{

    AVPacket  packet;

    int err;

    if( err == 0)

    {

        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.pts != AV_NOPTS_VALUE)

                    audio_base = get_audio_base() * packet.pts;

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

            };

        }

        else av_free_packet(&packet);

    }

    else if (err != AVERROR_EOF)

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

}

{

    int err = 0;

    AVPacket  packet;

            !err )

        err = load_frame();

{

    AVPacket  packet;

    avcodec_flush_buffers(aCodecCtx);

    while( get_packet(&q_video, &packet) != 0)

        av_free_packet(&packet);

        av_free_packet(&packet);

};

{

    int       eof;

    AVPacket  packet;

    int       ret;

    int64_t   min_pos, max_pos;

    {

        int err;

        {

            case PREPARE:

                eof = fill_queue();

                {

                    if( (q_video.size+q_audio.size < 4*1024*1024) &&

                        (eof == 0) )

                    {

                        eof = load_frame();

                    }

                    decode_video(pCodecCtx, &q_video);

                    ret = decode_audio(aCodecCtx, &q_audio);

                }while(astream.count < resampler_size*2 &&

                       ret == 1);

                decoder_state = PLAY;

                player_state  = PLAY;

                if( (q_video.size+q_audio.size < 4*1024*1024) &&

                    (eof == 0) )

                {

                    eof = load_frame();

                    if(eof) printf("eof\n");

                }

                ret = decode_video(pCodecCtx, &q_video);

                ret|= decode_audio(aCodecCtx, &q_audio);

                {

                    decoder_state = STOP;

//                    printf("stop decoder\n");

                };

                delay(1);

                break;

                while(sound_state != STOP)

                    delay(1);

                    rewind_pos = pFormatCtx->start_time;

                else

                    rewind_pos = 0;

                                         rewind_pos, INT64_MAX, 0);

                break;

                while(sound_state != STOP)

                    yield();

                int opts = 0;

                if(rewind_pos < 0)

                {

                    rewind_pos = -rewind_pos;

                    opts = AVSEEK_FLAG_BACKWARD;

                };

                    rewind_pos += pFormatCtx->start_time;

                min_pos = rewind_pos - 1000000;

                max_pos = rewind_pos + 1000000;

                                         rewind_pos, INT64_MAX, 0);

//                                         rewind_pos, max_pos, opts);

//            __asm__ __volatile__("int3");

                {

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

                            (double)rewind_pos / AV_TIME_BASE);

                }

                decoder_state = PREPARE;

                break;

        }

    };

    {

        ret =  decode_video(pCodecCtx, &q_video);

        ret |= decode_audio(aCodecCtx, &q_audio);

        delay(1);

    };

    delay(50);

    player_state = CLOSED;

    delay(300);

};

>