Subversion Repositories Kolibri OS

#include 

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

int fplay_init_context(AVCodecContext *avctx);

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;

mutex_t driver_lock;

{

  return (double)av_q2d(pFormatCtx->streams[audioStream]->time_base)*1000;

};

{

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

    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;

   // Find the first video stream

    videoStream=-1;

    audioStream=-1;

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

    {

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

            && videoStream < 0)

        {

            videoStream=i;

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

            if(stream_duration == 0)

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

        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

    };

    mutex_init(&q_video.lock);

    mutex_init(&q_audio.lock);

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

    else

            aCodecCtx->request_channels = 2;

    {

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

        {

            WAVEHEADER       whdr;

            int fmt;

            int channels;

            aCodecCtx->sample_rate, aCodecCtx->channels, aCodecCtx->sample_fmt );

            whdr.riff_id = 0x46464952;

            whdr.riff_format = 0x45564157;

            whdr.wFormatTag = 0x01;

            whdr.nSamplesPerSec = aCodecCtx->sample_rate;

            whdr.nChannels = 2;

            whdr.wBitsPerSample = 16;

            {

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

                if( decoder_buffer != NULL )

                {

                    mutex_init(&astream.lock);

                    astream.count  = 0;

                    astream.buffer = (char *)av_mallocz(192000*3);

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

           (AUDIO_THREAD | VIDEO_THREAD))

           delay(1);

        mutex_destroy(&astream.lock);

    mutex_destroy(&q_video.lock);

    mutex_destroy(&q_audio.lock);

}

{

    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, vret, aret;

    {

        int err;

        {

            case PREPARE:

                eof = fill_queue();

                {

                    if( (q_video.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 < 4*1024*1024) &&

                    (eof == 0) )

                {

                    eof = load_frame();

                }

                vret = decode_video(pCodecCtx, &q_video);

                aret = decode_audio(aCodecCtx, &q_audio);

                ret = vret | aret;

                {

                    decoder_state = STOP;

                    continue;

                };

                {

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

                        (eof == 0) )

                    {

                        eof = load_frame();

                        yield();

                        continue;

                    };

                    delay(1);

                    continue;

                }

                continue;

                delay(1);

                continue;

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

                {

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

                            (double)rewind_pos / AV_TIME_BASE);

                }

                decoder_state = PREPARE;

                break;

        }

    };

>