Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include "winlib/winlib.h"

#include "fplay.h"

int va_check_codec_support(enum AVCodecID id);

#endif

volatile enum player_state decoder_state = PREPARE;

volatile enum player_state sound_state   = STOP;

extern int resampler_size;

char *movie_file;

{

    return (double)av_q2d(vst->fCtx->streams[vst->aStream]->time_base)*1000;

};

{

    static vst_t vst;

    int i, ret;

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

    fplay_vaapi_init();

#endif

    {

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

        return -1; // Couldn't open file

    };

    if(avformat_find_stream_info(vst.fCtx, 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;

    vst.vStream = -1;

    vst.aStream = -1;

    {

        if(vst.fCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO

            && vst.vStream < 0)

        {

            vst.vStream = i;

            video_time_base = vst.fCtx->streams[i]->time_base;

            if(stream_duration == 0)

               stream_duration = vst.fCtx->streams[i]->duration;

        }

           vst.aStream < 0)

        {

            vst.aStream = i;

            if(stream_duration == 0)

               stream_duration = vst.fCtx->streams[i]->duration;

        }

    }

    {

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

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

    };

    vst.vCtx = vst.fCtx->streams[vst.vStream]->codec;

    vst.aCtx = vst.fCtx->streams[vst.aStream]->codec;

    printf("codec id %x name %s\n",vst.vCtx->codec_id, vst.vCodec->name);

    printf("ctx->pix_fmt %d\n", vst.vCtx->pix_fmt);

    {

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

        vst.vCtx->codec_id, vst.vStream);

        return -1; // Codec not found

    }

    int hwdec = va_check_codec_support(vst.vCtx->codec_id);

    {

        printf("hardware decode supported\n");

        {

            printf("context initialization failed\n");

            return -1;

        };

    };

#endif

    {

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

                vst.vStream);

        return -1; // Could not open codec

    };

    mutex_init(&vst.q_audio.lock);

    mutex_init(&vst.gpu_lock);

        vst.aCtx->request_channels = FFMIN(2, vst.aCtx->channels);

    else

        vst.aCtx->request_channels = 2;

    {

        if(avcodec_open2(vst.aCtx, vst.aCodec, NULL) >= 0 )

        {

            WAVEHEADER       whdr;

            int fmt;

            int channels;

            vst.aCtx->sample_rate, vst.aCtx->channels, vst.aCtx->sample_fmt );

            whdr.riff_id = 0x46464952;

            whdr.riff_format = 0x45564157;

            whdr.wFormatTag = 0x01;

            whdr.nSamplesPerSec = vst.aCtx->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(&vst.q_audio.lock);

}

{

    AVPacket  packet;

    int err;

    if( err == 0)

    {

        if(packet.stream_index == vst->vStream)

            put_packet(&vst->q_video, &packet);

        else if( (packet.stream_index == vst->aStream) &&

                  (have_sound != 0) )

        {

            put_packet(&vst->q_audio, &packet);

            if(audio_base == -1.0)

            {

                if (packet.pts != AV_NOPTS_VALUE)

                    audio_base = get_audio_base(vst) * 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 = load_frame(vst);

};

{

    AVPacket  packet;

    avcodec_flush_buffers(vst->aCtx);

    while( get_packet(&vst->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(vst);

                {

                    if( (vst->q_video.size < 4*1024*1024) &&

                        (eof == 0) )

                    {

                        eof = load_frame(vst);

                    }

                    decode_video(vst);

                    ret = decode_audio(vst->aCtx, &vst->q_audio);

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

                       ret == 1);

                decoder_state = PLAY;

                player_state  = PLAY;

                if( (vst->q_video.size < 4*1024*1024) &&

                    (eof == 0) )

                {

                    eof = load_frame(vst);

                }

                vret = decode_video(vst);

                aret = decode_audio(vst->aCtx, &vst->q_audio);

                ret = vret | aret;

                {

                    decoder_state = STOP;

                    continue;

                };

                {

                    if( (vst->q_video.size < 4*1024*1024) &&

                        (eof == 0) )

                    {

                        eof = load_frame(vst);

                        yield();

                        continue;

                    };

                    delay(1);

                    continue;

                }

                continue;

                delay(1);

                continue;

                while(sound_state != STOP)

                    delay(1);

                    rewind_pos = vst->fCtx->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 += vst->fCtx->start_time;

                min_pos = rewind_pos - 1000000;

                max_pos = rewind_pos + 1000000;

                                         rewind_pos, INT64_MAX, 0);

                if (ret < 0)

                {

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

                            (double)rewind_pos / AV_TIME_BASE);

                }

                decoder_state = PREPARE;

                break;

        }

    };

};