Subversion Repositories Kolibri OS

#include 

#include "list.h"

#define BLACK_MAGIC_VIDEO

typedef unsigned int count_t;

typedef struct vstate vst_t;

#define HAS_TOP         (1<<1)

#define HAS_RIGHT       (1<<2)

#define HAS_BOTTOM      (1<<3)

{

    struct list_head list;

    enum AVPixelFormat format;

    AVPicture     picture;

    planar_t*     planar;

    int           is_hw_pic;

    int           index;

    double        pts;

    double        pkt_pts;

    volatile int  ready;

}vframe_t;

{

    vst_t     *vst;

    uint32_t   caps;

    uint32_t   ctx_width;

    uint32_t   ctx_height;

    uint32_t   win_width;

    uint32_t   win_height;

    rect_t     rcvideo;

    rect_t     rcleft;

    rect_t     rctop;

    rect_t     rcright;

    rect_t     rcbottom;

    bitmap_t  *bitmap[4];

    bitmap_t  *last_bitmap;

    int        target;

    enum{

      EMPTY, INIT }state;

    enum win_state win_state;

};

{

    CLOSED = 0,

    PREPARE,

    STOP,

    PAUSE,

    PLAY,

    REWIND,

    PLAY_2_STOP,

    PLAY_2_PAUSE,

    PAUSE_2_PLAY,

    REWIND_2_PLAY,

};

#define ID_STOP             101

#define ID_PROGRESS         102

#define ID_VOL_LEVEL        103

#define ID_VOL_CTRL         104

{

    mutex_t lock;

    char    *buffer;

    int     count;

}astream_t;

{

  unsigned int  code;

  unsigned int  sender;

  unsigned int  stream;

  unsigned int  offset;

  unsigned int  size;

  unsigned int  unused[2];

}SND_EVENT;

    AVPacketList *first_pkt;

    AVPacketList *last_pkt;

    int size;

    int count;

    mutex_t       lock;

} queue_t;

int get_packet(queue_t *q, AVPacket *pkt);

{

    const char     *name;

    enum AVCodecID  codec_id;

    enum AVPixelFormat pix_fmt;

    int             width;

    int             height;

    AVFrame        *Frame;

    vframe_t       *active_frame;

    void           *hwctx;

    int             is_hw:1;

    int             frame_reorder:1;

    int             nframes;

    vframe_t        vframes[16];

};

{

    AVFormatContext *fCtx;              /* format context           */

    AVCodecContext  *vCtx;              /* video decoder context    */

    AVCodecContext  *aCtx;              /* audio decoder context    */

    AVCodec         *vCodec;            /* video codec              */

    AVCodec         *aCodec;            /* audio codec              */

    enum AVCodecID  codec_id;

    int             codec_profile;

    char            *input_file;

    char            *input_name;

    int             vStream;            /* video stream index       */

    int             aStream;            /* audio stream index       */

    AVRational      video_time_base;

    double          audio_timer_base;

    queue_t         q_audio;            /* audio packets queue      */

    mutex_t         decoder_lock;

    mutex_t         output_lock;

    struct list_head input_list;

    struct list_head output_list;

    int             snd_format;

    volatile int    frames_count;

    unsigned int    has_sound:1;

    unsigned int    audio_timer_valid:1;

    unsigned int    blit_bitmap:1;      /* hardware RGBA blitter    */

    unsigned int    blit_texture:1;     /* hardware RGBA blit and scale */

    unsigned int    blit_planar:1;      /* hardbare YUV blit and scale */

};

#define AUDIO_THREAD    2

#define VIDEO_THREAD    4

extern astream_t astream;

void destroy_render(render_t *render);

int init_render(render_t *render, int width, int height);

void render_adjust_size(render_t *render, window_t *win);

void render_set_size(render_t *render, int width, int height);

void render_draw_client(render_t *render);

int audio_thread(void *param);

void set_audio_volume(int left, int right);

void flush_video(vst_t* vst);

void fini_video_decoder(vst_t *vst);

void decoder(vst_t *vst);

int decode_video(vst_t* vst);

int decode_audio(AVCodecContext  *ctx, queue_t *qa);

{

    __asm__ __volatile__ (

    "int $0x40"

    ::"a"(68),"b"(14),"c"(event));

}

{

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

};

void va_create_planar(vst_t *vst, vframe_t *vframe);

char *get_moviefile();

#define LEAVE()   printf("leave %s\n",__FUNCTION__)

#define FAIL()    printf("fail %s\n",__FUNCTION__)