Subversion Repositories Kolibri OS

 

 

 

 

 

 

 

const char program_name[] = "ffplay";

const int program_birth_year = 2003;

 

 

 

 

 

 

 

 

 

 

static int64_t sws_flags = SWS_BICUBIC;

 

typedef struct MyAVPacketList {

    AVPacket pkt;

    struct MyAVPacketList *next;

    int serial;

} MyAVPacketList;

 

typedef struct PacketQueue {

    MyAVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    int abort_request;

    int serial;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;

 

 

typedef struct VideoPicture {

    double pts;             // presentation timestamp for this picture

    int64_t pos;            // byte position in file

    SDL_Overlay *bmp;

    int width, height; /* source height & width */

    int allocated;

    int reallocate;

    int serial;

 

    AVRational sar;

} VideoPicture;

 

typedef struct SubPicture {

    double pts; /* presentation time stamp for this picture */

    AVSubtitle sub;

    int serial;

} SubPicture;

 

typedef struct AudioParams {

    int freq;

    int channels;

    int64_t channel_layout;

    enum AVSampleFormat fmt;

} AudioParams;

 

typedef struct Clock {

    double pts;           /* clock base */

    double pts_drift;     /* clock base minus time at which we updated the clock */

    double last_updated;

    double speed;

    int serial;           /* clock is based on a packet with this serial */

    int paused;

    int *queue_serial;    /* pointer to the current packet queue serial, used for obsolete clock detection */

} Clock;

 

enum {

    AV_SYNC_AUDIO_MASTER, /* default choice */

    AV_SYNC_VIDEO_MASTER,

    AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */

 

typedef struct VideoState {

    SDL_Thread *read_tid;

    SDL_Thread *video_tid;

    AVInputFormat *iformat;

    int no_background;

    int abort_request;

    int force_refresh;

    int paused;

    int last_paused;

    int queue_attachments_req;

    int seek_req;

    int seek_flags;

    int64_t seek_pos;

    int64_t seek_rel;

    int read_pause_return;

    AVFormatContext *ic;

    int realtime;

    int audio_finished;

    int video_finished;

 

    Clock audclk;

    Clock vidclk;

    Clock extclk;

 

    int audio_stream;

 

    int av_sync_type;

 

    double audio_clock;

    int audio_clock_serial;

    double audio_diff_cum; /* used for AV difference average computation */

    double audio_diff_avg_coef;

    double audio_diff_threshold;

    int audio_diff_avg_count;

    AVStream *audio_st;

    PacketQueue audioq;

    int audio_hw_buf_size;

    uint8_t silence_buf[SDL_AUDIO_BUFFER_SIZE];

    uint8_t *audio_buf;

    uint8_t *audio_buf1;

    unsigned int audio_buf_size; /* in bytes */

    unsigned int audio_buf1_size;

    int audio_buf_index; /* in bytes */

    int audio_write_buf_size;

    int audio_buf_frames_pending;

    AVPacket audio_pkt_temp;

    AVPacket audio_pkt;

    int audio_pkt_temp_serial;

    int audio_last_serial;

    struct AudioParams audio_src;

    struct AudioParams audio_filter_src;

    struct AudioParams audio_tgt;

    struct SwrContext *swr_ctx;

    int frame_drops_early;

    int frame_drops_late;

    AVFrame *frame;

    int64_t audio_frame_next_pts;

 

    enum ShowMode {

        SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB

    } show_mode;

    int16_t sample_array[SAMPLE_ARRAY_SIZE];

    int sample_array_index;

    int last_i_start;

    RDFTContext *rdft;

    int rdft_bits;

    FFTSample *rdft_data;

    int xpos;

    double last_vis_time;

 

    SDL_Thread *subtitle_tid;

    int subtitle_stream;

    AVStream *subtitle_st;

    PacketQueue subtitleq;

    SubPicture subpq[SUBPICTURE_QUEUE_SIZE];

    int subpq_size, subpq_rindex, subpq_windex;

    SDL_mutex *subpq_mutex;

    SDL_cond *subpq_cond;

 

    double frame_timer;

    double frame_last_pts;

    double frame_last_duration;

    double frame_last_dropped_pts;

    double frame_last_returned_time;

    double frame_last_filter_delay;

    int64_t frame_last_dropped_pos;

    int frame_last_dropped_serial;

    int video_stream;

    AVStream *video_st;

    PacketQueue videoq;

    int64_t video_current_pos;      // current displayed file pos

    double max_frame_duration;      // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity

    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;

    struct SwsContext *img_convert_ctx;

    SDL_Rect last_display_rect;

 

    char filename[1024];

    int width, height, xleft, ytop;

    int step;

 

    AVFilterContext *in_video_filter;   // the first filter in the video chain

    AVFilterContext *out_video_filter;  // the last filter in the video chain

    AVFilterContext *in_audio_filter;   // the first filter in the audio chain

    AVFilterContext *out_audio_filter;  // the last filter in the audio chain

    AVFilterGraph *agraph;              // audio filter graph

 

    int last_video_stream, last_audio_stream, last_subtitle_stream;

 

    SDL_cond *continue_read_thread;

} VideoState;

 

static AVInputFormat *file_iformat;

static const char *input_filename;

static const char *window_title;

static int fs_screen_width;

static int fs_screen_height;

static int default_width  = 640;

static int default_height = 480;

static int screen_width  = 0;

static int screen_height = 0;

static int audio_disable;

static int video_disable;

static int subtitle_disable;

static int wanted_stream[AVMEDIA_TYPE_NB] = {

    [AVMEDIA_TYPE_AUDIO]    = -1,

    [AVMEDIA_TYPE_VIDEO]    = -1,

    [AVMEDIA_TYPE_SUBTITLE] = -1,

static int seek_by_bytes = -1;

static int display_disable;

static int show_status = 1;

static int av_sync_type = AV_SYNC_AUDIO_MASTER;

static int64_t start_time = AV_NOPTS_VALUE;

static int64_t duration = AV_NOPTS_VALUE;

static int workaround_bugs = 1;

static int fast = 0;

static int genpts = 0;

static int lowres = 0;

static int error_concealment = 3;

static int decoder_reorder_pts = -1;

static int autoexit;

static int exit_on_keydown;

static int exit_on_mousedown;

static int loop = 1;

static int framedrop = -1;

static int infinite_buffer = -1;

static enum ShowMode show_mode = SHOW_MODE_NONE;

static const char *audio_codec_name;

static const char *subtitle_codec_name;

static const char *video_codec_name;

double rdftspeed = 0.02;

static int64_t cursor_last_shown;

static int cursor_hidden = 0;

static char *vfilters = NULL;

static char *afilters = NULL;

 

static int is_full_screen;

static int64_t audio_callback_time;

 

static AVPacket flush_pkt;

 

 

static SDL_Surface *screen;

 

static inline

int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,

                   enum AVSampleFormat fmt2, int64_t channel_count2)

    /* If channel count == 1, planar and non-planar formats are the same */

    if (channel_count1 == 1 && channel_count2 == 1)

        return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);

    else

        return channel_count1 != channel_count2 || fmt1 != fmt2;

 

static inline

int64_t get_valid_channel_layout(int64_t channel_layout, int channels)

    if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)

        return channel_layout;

    else

        return 0;

 

static int packet_queue_put(PacketQueue *q, AVPacket *pkt);

 

static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)

    MyAVPacketList *pkt1;

 

    if (q->abort_request)

       return -1;

 

    pkt1 = av_malloc(sizeof(MyAVPacketList));

    if (!pkt1)

        return -1;

    pkt1->pkt = *pkt;

    pkt1->next = NULL;

    if (pkt == &flush_pkt)

        q->serial++;

    pkt1->serial = q->serial;

 

    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;

    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size + sizeof(*pkt1);

    /* XXX: should duplicate packet data in DV case */

    SDL_CondSignal(q->cond);

    return 0;

 

static int packet_queue_put(PacketQueue *q, AVPacket *pkt)

    int ret;

 

    /* duplicate the packet */

    if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)

        return -1;

 

    SDL_LockMutex(q->mutex);

    ret = packet_queue_put_private(q, pkt);

    SDL_UnlockMutex(q->mutex);

 

    if (pkt != &flush_pkt && ret < 0)

        av_free_packet(pkt);

 

    return ret;

 

static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)

    AVPacket pkt1, *pkt = &pkt1;

    av_init_packet(pkt);

    pkt->data = NULL;

    pkt->size = 0;

    pkt->stream_index = stream_index;

    return packet_queue_put(q, pkt);

 

static void packet_queue_init(PacketQueue *q)

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

    q->abort_request = 1;

 

static void packet_queue_flush(PacketQueue *q)

    MyAVPacketList *pkt, *pkt1;

 

    SDL_LockMutex(q->mutex);

    for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {

        pkt1 = pkt->next;

        av_free_packet(&pkt->pkt);

        av_freep(&pkt);

    }

    q->last_pkt = NULL;

    q->first_pkt = NULL;

    q->nb_packets = 0;

    q->size = 0;

    SDL_UnlockMutex(q->mutex);

 

static void packet_queue_destroy(PacketQueue *q)

    packet_queue_flush(q);

    SDL_DestroyMutex(q->mutex);

    SDL_DestroyCond(q->cond);

 

static void packet_queue_abort(PacketQueue *q)

    SDL_LockMutex(q->mutex);

 

    q->abort_request = 1;

 

    SDL_CondSignal(q->cond);

 

    SDL_UnlockMutex(q->mutex);

 

static void packet_queue_start(PacketQueue *q)

    SDL_LockMutex(q->mutex);

    q->abort_request = 0;

    packet_queue_put_private(q, &flush_pkt);

    SDL_UnlockMutex(q->mutex);

 

static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)

    MyAVPacketList *pkt1;

    int ret;

 

    SDL_LockMutex(q->mutex);

 

    for (;;) {

        if (q->abort_request) {

            ret = -1;

            break;

        }

 

        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size + sizeof(*pkt1);

            *pkt = pkt1->pkt;

            if (serial)

                *serial = pkt1->serial;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

            break;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }

    SDL_UnlockMutex(q->mutex);

    return ret;

 

static inline void fill_rectangle(SDL_Surface *screen,

                                  int x, int y, int w, int h, int color, int update)

    SDL_Rect rect;

    rect.x = x;

    rect.y = y;

    rect.w = w;

    rect.h = h;

    SDL_FillRect(screen, &rect, color);

    if (update && w > 0 && h > 0)

        SDL_UpdateRect(screen, x, y, w, h);

 

static void fill_border(int xleft, int ytop, int width, int height, int x, int y, int w, int h, int color, int update)

    int w1, w2, h1, h2;

 

    /* fill the background */

    w1 = x;

    if (w1 < 0)

        w1 = 0;

    w2 = width - (x + w);

    if (w2 < 0)

        w2 = 0;

    h1 = y;

    if (h1 < 0)

        h1 = 0;

    h2 = height - (y + h);

    if (h2 < 0)

        h2 = 0;

    fill_rectangle(screen,

                   xleft, ytop,

                   w1, height,

                   color, update);

    fill_rectangle(screen,

                   xleft + width - w2, ytop,

                   w2, height,

                   color, update);

    fill_rectangle(screen,

                   xleft + w1, ytop,

                   width - w1 - w2, h1,

                   color, update);

    fill_rectangle(screen,

                   xleft + w1, ytop + height - h2,

                   width - w1 - w2, h2,

                   color, update);

 

 

 

 

 

 

 

static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)

    int wrap, wrap3, width2, skip2;

    int y, u, v, a, u1, v1, a1, w, h;

    uint8_t *lum, *cb, *cr;

    const uint8_t *p;

    const uint32_t *pal;

    int dstx, dsty, dstw, dsth;

 

    dstw = av_clip(rect->w, 0, imgw);

    dsth = av_clip(rect->h, 0, imgh);

    dstx = av_clip(rect->x, 0, imgw - dstw);

    dsty = av_clip(rect->y, 0, imgh - dsth);

    lum = dst->data[0] + dsty * dst->linesize[0];

    cb  = dst->data[1] + (dsty >> 1) * dst->linesize[1];

    cr  = dst->data[2] + (dsty >> 1) * dst->linesize[2];

 

    width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);

    skip2 = dstx >> 1;

    wrap = dst->linesize[0];

    wrap3 = rect->pict.linesize[0];

    p = rect->pict.data[0];

    pal = (const uint32_t *)rect->pict.data[1];  /* Now in YCrCb! */

 

    if (dsty & 1) {

        lum += dstx;

        cb += skip2;

        cr += skip2;

 

        if (dstx & 1) {

            YUVA_IN(y, u, v, a, p, pal);

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);

            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);

            cb++;

            cr++;

            lum++;

            p += BPP;

        }

        for (w = dstw - (dstx & 1); w >= 2; w -= 2) {

            YUVA_IN(y, u, v, a, p, pal);

            u1 = u;

            v1 = v;

            a1 = a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

 

            YUVA_IN(y, u, v, a, p + BPP, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);

            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);

            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);

            cb++;

            cr++;

            p += 2 * BPP;

            lum += 2;

        }

        if (w) {

            YUVA_IN(y, u, v, a, p, pal);

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);

            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);

            p++;

            lum++;

        }

        p += wrap3 - dstw * BPP;

        lum += wrap - dstw - dstx;

        cb += dst->linesize[1] - width2 - skip2;

        cr += dst->linesize[2] - width2 - skip2;

    }

    for (h = dsth - (dsty & 1); h >= 2; h -= 2) {

        lum += dstx;

        cb += skip2;

        cr += skip2;

 

        if (dstx & 1) {

            YUVA_IN(y, u, v, a, p, pal);

            u1 = u;

            v1 = v;

            a1 = a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            p += wrap3;

            lum += wrap;

            YUVA_IN(y, u, v, a, p, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);

            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);

            cb++;

            cr++;

            p += -wrap3 + BPP;

            lum += -wrap + 1;

        }

        for (w = dstw - (dstx & 1); w >= 2; w -= 2) {

            YUVA_IN(y, u, v, a, p, pal);

            u1 = u;

            v1 = v;

            a1 = a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

 

            YUVA_IN(y, u, v, a, p + BPP, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);

            p += wrap3;

            lum += wrap;

 

            YUVA_IN(y, u, v, a, p, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

 

            YUVA_IN(y, u, v, a, p + BPP, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);

 

            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);

            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);

 

            cb++;

            cr++;

            p += -wrap3 + 2 * BPP;

            lum += -wrap + 2;

        }

        if (w) {

            YUVA_IN(y, u, v, a, p, pal);

            u1 = u;

            v1 = v;

            a1 = a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            p += wrap3;

            lum += wrap;

            YUVA_IN(y, u, v, a, p, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);

            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);

            cb++;

            cr++;

            p += -wrap3 + BPP;

            lum += -wrap + 1;

        }

        p += wrap3 + (wrap3 - dstw * BPP);

        lum += wrap + (wrap - dstw - dstx);

        cb += dst->linesize[1] - width2 - skip2;

        cr += dst->linesize[2] - width2 - skip2;

    }

    /* handle odd height */

    if (h) {

        lum += dstx;

        cb += skip2;

        cr += skip2;

 

        if (dstx & 1) {

            YUVA_IN(y, u, v, a, p, pal);

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);

            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);

            cb++;

            cr++;

            lum++;

            p += BPP;

        }

        for (w = dstw - (dstx & 1); w >= 2; w -= 2) {

            YUVA_IN(y, u, v, a, p, pal);

            u1 = u;

            v1 = v;

            a1 = a;

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

 

            YUVA_IN(y, u, v, a, p + BPP, pal);

            u1 += u;

            v1 += v;

            a1 += a;

            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);

            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);

            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);

            cb++;

            cr++;

            p += 2 * BPP;

            lum += 2;

        }

        if (w) {

            YUVA_IN(y, u, v, a, p, pal);

            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);

            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);

        }

    }

 

static void free_picture(VideoPicture *vp)

     if (vp->bmp) {

         SDL_FreeYUVOverlay(vp->bmp);

         vp->bmp = NULL;

     }

 

static void free_subpicture(SubPicture *sp)

    avsubtitle_free(&sp->sub);

 

static void calculate_display_rect(SDL_Rect *rect, int scr_xleft, int scr_ytop, int scr_width, int scr_height, VideoPicture *vp)

    float aspect_ratio;

    int width, height, x, y;

 

    if (vp->sar.num == 0)

        aspect_ratio = 0;

    else

        aspect_ratio = av_q2d(vp->sar);

 

    if (aspect_ratio <= 0.0)

        aspect_ratio = 1.0;

    aspect_ratio *= (float)vp->width / (float)vp->height;

 

    /* XXX: we suppose the screen has a 1.0 pixel ratio */

    height = scr_height;

    width = ((int)rint(height * aspect_ratio)) & ~1;

    if (width > scr_width) {

        width = scr_width;

        height = ((int)rint(width / aspect_ratio)) & ~1;

    }

    x = (scr_width - width) / 2;

    y = (scr_height - height) / 2;

    rect->x = scr_xleft + x;

    rect->y = scr_ytop  + y;

    rect->w = FFMAX(width,  1);

    rect->h = FFMAX(height, 1);

 

static void video_image_display(VideoState *is)

    VideoPicture *vp;

    SubPicture *sp;

    AVPicture pict;

    SDL_Rect rect;

    int i;

 

    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->subtitle_st) {

            if (is->subpq_size > 0) {

                sp = &is->subpq[is->subpq_rindex];

 

                if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {

                    SDL_LockYUVOverlay (vp->bmp);

 

                    pict.data[0] = vp->bmp->pixels[0];

                    pict.data[1] = vp->bmp->pixels[2];

                    pict.data[2] = vp->bmp->pixels[1];

 

                    pict.linesize[0] = vp->bmp->pitches[0];

                    pict.linesize[1] = vp->bmp->pitches[2];

                    pict.linesize[2] = vp->bmp->pitches[1];

 

                    for (i = 0; i < sp->sub.num_rects; i++)

                        blend_subrect(&pict, sp->sub.rects[i],

                                      vp->bmp->w, vp->bmp->h);

 

                    SDL_UnlockYUVOverlay (vp->bmp);

                }

            }

        }

 

        calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp);

 

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

 

        if (rect.x != is->last_display_rect.x || rect.y != is->last_display_rect.y || rect.w != is->last_display_rect.w || rect.h != is->last_display_rect.h || is->force_refresh) {

            int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);

            fill_border(is->xleft, is->ytop, is->width, is->height, rect.x, rect.y, rect.w, rect.h, bgcolor, 1);

            is->last_display_rect = rect;

        }

    }

 

static inline int compute_mod(int a, int b)

    return a < 0 ? a%b + b : a%b;

 

static void video_audio_display(VideoState *s)

    int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;

    int ch, channels, h, h2, bgcolor, fgcolor;

    int64_t time_diff;

    int rdft_bits, nb_freq;

 

    for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)

        ;

    nb_freq = 1 << (rdft_bits - 1);

 

    /* compute display index : center on currently output samples */

    channels = s->audio_tgt.channels;

    nb_display_channels = channels;

    if (!s->paused) {

        int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);

        n = 2 * channels;

        delay = s->audio_write_buf_size;

        delay /= n;

 

        /* to be more precise, we take into account the time spent since

        if (audio_callback_time) {

            time_diff = av_gettime() - audio_callback_time;

            delay -= (time_diff * s->audio_tgt.freq) / 1000000;

        }

 

        delay += 2 * data_used;

        if (delay < data_used)

            delay = data_used;

 

        i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);

        if (s->show_mode == SHOW_MODE_WAVES) {

            h = INT_MIN;

            for (i = 0; i < 1000; i += channels) {

                int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;

                int a = s->sample_array[idx];

                int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];

                int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];

                int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];

                int score = a - d;

                if (h < score && (b ^ c) < 0) {

                    h = score;

                    i_start = idx;

                }

            }

        }

 

        s->last_i_start = i_start;

    } else {

        i_start = s->last_i_start;

    }

 

    bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);

    if (s->show_mode == SHOW_MODE_WAVES) {

        fill_rectangle(screen,

                       s->xleft, s->ytop, s->width, s->height,

                       bgcolor, 0);

 

        fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);

 

        /* total height for one channel */

        h = s->height / nb_display_channels;

        /* graph height / 2 */

        h2 = (h * 9) / 20;

        for (ch = 0; ch < nb_display_channels; ch++) {

            i = i_start + ch;

            y1 = s->ytop + ch * h + (h / 2); /* position of center line */

            for (x = 0; x < s->width; x++) {

                y = (s->sample_array[i] * h2) >> 15;

                if (y < 0) {

                    y = -y;

                    ys = y1 - y;

                } else {

                    ys = y1;

                }

                fill_rectangle(screen,

                               s->xleft + x, ys, 1, y,

                               fgcolor, 0);

                i += channels;

                if (i >= SAMPLE_ARRAY_SIZE)

                    i -= SAMPLE_ARRAY_SIZE;

            }

        }

 

        fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);

 

        for (ch = 1; ch < nb_display_channels; ch++) {

            y = s->ytop + ch * h;

            fill_rectangle(screen,

                           s->xleft, y, s->width, 1,

                           fgcolor, 0);

        }

        SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);

    } else {

        nb_display_channels= FFMIN(nb_display_channels, 2);

        if (rdft_bits != s->rdft_bits) {

            av_rdft_end(s->rdft);

            av_free(s->rdft_data);

            s->rdft = av_rdft_init(rdft_bits, DFT_R2C);

            s->rdft_bits = rdft_bits;

            s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));

        }

        {

            FFTSample *data[2];

            for (ch = 0; ch < nb_display_channels; ch++) {

                data[ch] = s->rdft_data + 2 * nb_freq * ch;

                i = i_start + ch;

                for (x = 0; x < 2 * nb_freq; x++) {

                    double w = (x-nb_freq) * (1.0 / nb_freq);

                    data[ch][x] = s->sample_array[i] * (1.0 - w * w);

                    i += channels;

                    if (i >= SAMPLE_ARRAY_SIZE)

                        i -= SAMPLE_ARRAY_SIZE;

                }

                av_rdft_calc(s->rdft, data[ch]);

            }

            /* Least efficient way to do this, we should of course

            for (y = 0; y < s->height; y++) {

                double w = 1 / sqrt(nb_freq);

                int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));

                int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]

                       + data[1][2 * y + 1] * data[1][2 * y + 1])) : a;

                a = FFMIN(a, 255);

                b = FFMIN(b, 255);

                fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);

 

                fill_rectangle(screen,

                            s->xpos, s->height-y, 1, 1,

                            fgcolor, 0);

            }

        }

        SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);

        if (!s->paused)

            s->xpos++;

        if (s->xpos >= s->width)

            s->xpos= s->xleft;

    }

 

static void stream_close(VideoState *is)

    int i;

    /* XXX: use a special url_shutdown call to abort parse cleanly */

    is->abort_request = 1;

    SDL_WaitThread(is->read_tid, NULL);

    packet_queue_destroy(&is->videoq);

    packet_queue_destroy(&is->audioq);

    packet_queue_destroy(&is->subtitleq);

 

    /* free all pictures */

    for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)

        free_picture(&is->pictq[i]);

    for (i = 0; i < SUBPICTURE_QUEUE_SIZE; i++)

        free_subpicture(&is->subpq[i]);

    SDL_DestroyMutex(is->pictq_mutex);

    SDL_DestroyCond(is->pictq_cond);

    SDL_DestroyMutex(is->subpq_mutex);

    SDL_DestroyCond(is->subpq_cond);

    SDL_DestroyCond(is->continue_read_thread);

    sws_freeContext(is->img_convert_ctx);

    av_free(is);

 

static void do_exit(VideoState *is)

    if (is) {

        stream_close(is);

    }

    av_lockmgr_register(NULL);

    uninit_opts();

    av_freep(&vfilters);

    avformat_network_deinit();

    if (show_status)

        printf("\n");

    SDL_Quit();

    av_log(NULL, AV_LOG_QUIET, "%s", "");

    exit(0);

 

static void sigterm_handler(int sig)

    exit(123);

 

static int video_open(VideoState *is, int force_set_video_mode, VideoPicture *vp)

    int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;

    int w,h;

    SDL_Rect rect;

 

    if (is_full_screen) flags |= SDL_FULLSCREEN;

    else                flags |= SDL_RESIZABLE;

 

    if (vp && vp->width) {

        calculate_display_rect(&rect, 0, 0, INT_MAX, vp->height, vp);

        default_width  = rect.w;

        default_height = rect.h;

    }

 

    if (is_full_screen && fs_screen_width) {

        w = fs_screen_width;

        h = fs_screen_height;

    } else if (!is_full_screen && screen_width) {

        w = screen_width;

        h = screen_height;

    } else {

        w = default_width;

        h = default_height;

    }

    w = FFMIN(16383, w);

    if (screen && is->width == screen->w && screen->w == w

       && is->height== screen->h && screen->h == h && !force_set_video_mode)

        return 0;

    screen = SDL_SetVideoMode(w, h, 0, flags);

    if (!screen) {

        av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");

        do_exit(is);

    }

    if (!window_title)

        window_title = input_filename;

    SDL_WM_SetCaption(window_title, window_title);

 

    is->width  = screen->w;

    is->height = screen->h;

 

    return 0;

 

static void video_display(VideoState *is)

    if (!screen)

        video_open(is, 0, NULL);

    if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)

        video_audio_display(is);

    else if (is->video_st)

        video_image_display(is);

 

static double get_clock(Clock *c)

    if (*c->queue_serial != c->serial)

        return NAN;

    if (c->paused) {

        return c->pts;

    } else {

        double time = av_gettime() / 1000000.0;

        return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);

    }

 

static void set_clock_at(Clock *c, double pts, int serial, double time)

    c->pts = pts;

    c->last_updated = time;

    c->pts_drift = c->pts - time;

    c->serial = serial;

 

static void set_clock(Clock *c, double pts, int serial)

    double time = av_gettime() / 1000000.0;

    set_clock_at(c, pts, serial, time);

 

static void set_clock_speed(Clock *c, double speed)

    set_clock(c, get_clock(c), c->serial);

    c->speed = speed;

 

static void init_clock(Clock *c, int *queue_serial)

    c->speed = 1.0;

    c->paused = 0;

    c->queue_serial = queue_serial;

    set_clock(c, NAN, -1);

 

static void sync_clock_to_slave(Clock *c, Clock *slave)

    double clock = get_clock(c);

    double slave_clock = get_clock(slave);

    if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))

        set_clock(c, slave_clock, slave->serial);

 

static int get_master_sync_type(VideoState *is) {

    if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {

        if (is->video_st)

            return AV_SYNC_VIDEO_MASTER;

        else

            return AV_SYNC_AUDIO_MASTER;

    } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {

        if (is->audio_st)

            return AV_SYNC_AUDIO_MASTER;

        else

            return AV_SYNC_EXTERNAL_CLOCK;

    } else {

        return AV_SYNC_EXTERNAL_CLOCK;

    }

 

static double get_master_clock(VideoState *is)

    double val;

 

    switch (get_master_sync_type(is)) {

        case AV_SYNC_VIDEO_MASTER:

            val = get_clock(&is->vidclk);

            break;

        case AV_SYNC_AUDIO_MASTER:

            val = get_clock(&is->audclk);

            break;

        default:

            val = get_clock(&is->extclk);

            break;

    }

    return val;

 

static void check_external_clock_speed(VideoState *is) {

   if (is->video_stream >= 0 && is->videoq.nb_packets <= MIN_FRAMES / 2 ||

       is->audio_stream >= 0 && is->audioq.nb_packets <= MIN_FRAMES / 2) {

       set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));

   } else if ((is->video_stream < 0 || is->videoq.nb_packets > MIN_FRAMES * 2) &&

              (is->audio_stream < 0 || is->audioq.nb_packets > MIN_FRAMES * 2)) {

       set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));

   } else {

       double speed = is->extclk.speed;

       if (speed != 1.0)

           set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));

   }

 

static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)

    if (!is->seek_req) {

        is->seek_pos = pos;

        is->seek_rel = rel;

        is->seek_flags &= ~AVSEEK_FLAG_BYTE;

        if (seek_by_bytes)

            is->seek_flags |= AVSEEK_FLAG_BYTE;

        is->seek_req = 1;

        SDL_CondSignal(is->continue_read_thread);

    }

 

static void stream_toggle_pause(VideoState *is)

    if (is->paused) {

        is->frame_timer += av_gettime() / 1000000.0 + is->vidclk.pts_drift - is->vidclk.pts;

        if (is->read_pause_return != AVERROR(ENOSYS)) {

            is->vidclk.paused = 0;

        }

        set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);

    }

    set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);

    is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;

 

static void toggle_pause(VideoState *is)

    stream_toggle_pause(is);

    is->step = 0;

 

static void step_to_next_frame(VideoState *is)

    /* if the stream is paused unpause it, then step */

    if (is->paused)

        stream_toggle_pause(is);

    is->step = 1;

 

static double compute_target_delay(double delay, VideoState *is)

    double sync_threshold, diff;

 

    /* update delay to follow master synchronisation source */

    if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {

        /* if video is slave, we try to correct big delays by

        diff = get_clock(&is->vidclk) - get_master_clock(is);

 

        /* skip or repeat frame. We take into account the

        sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));

        if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {

            if (diff <= -sync_threshold)

                delay = FFMAX(0, delay + diff);

            else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)

                delay = delay + diff;

            else if (diff >= sync_threshold)

                delay = 2 * delay;

        }

    }

 

    av_dlog(NULL, "video: delay=%0.3f A-V=%f\n",

            delay, -diff);

 

    return delay;

 

static void pictq_next_picture(VideoState *is) {

    /* update queue size and signal for next picture */

    if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)

        is->pictq_rindex = 0;

 

    SDL_LockMutex(is->pictq_mutex);

    is->pictq_size--;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

 

static int pictq_prev_picture(VideoState *is) {

    VideoPicture *prevvp;

    int ret = 0;

    /* update queue size and signal for the previous picture */

    prevvp = &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) % VIDEO_PICTURE_QUEUE_SIZE];

    if (prevvp->allocated && prevvp->serial == is->videoq.serial) {

        SDL_LockMutex(is->pictq_mutex);

        if (is->pictq_size < VIDEO_PICTURE_QUEUE_SIZE) {

            if (--is->pictq_rindex == -1)

                is->pictq_rindex = VIDEO_PICTURE_QUEUE_SIZE - 1;

            is->pictq_size++;

            ret = 1;

        }

        SDL_CondSignal(is->pictq_cond);

        SDL_UnlockMutex(is->pictq_mutex);

    }

    return ret;

 

static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {

    /* update current video pts */

    set_clock(&is->vidclk, pts, serial);

    sync_clock_to_slave(&is->extclk, &is->vidclk);

    is->video_current_pos = pos;

    is->frame_last_pts = pts;

 

static void video_refresh(void *opaque, double *remaining_time)

    VideoState *is = opaque;

    VideoPicture *vp;

    double time;

 

    SubPicture *sp, *sp2;

 

    if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)

        check_external_clock_speed(is);

 

    if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {

        time = av_gettime() / 1000000.0;

        if (is->force_refresh || is->last_vis_time + rdftspeed < time) {

            video_display(is);

            is->last_vis_time = time;

        }

        *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);

    }

 

    if (is->video_st) {

        int redisplay = 0;

        if (is->force_refresh)

            redisplay = pictq_prev_picture(is);

retry:

        if (is->pictq_size == 0) {

            SDL_LockMutex(is->pictq_mutex);

            if (is->frame_last_dropped_pts != AV_NOPTS_VALUE && is->frame_last_dropped_pts > is->frame_last_pts) {

                update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos, is->frame_last_dropped_serial);

                is->frame_last_dropped_pts = AV_NOPTS_VALUE;

            }

            SDL_UnlockMutex(is->pictq_mutex);

            // nothing to do, no picture to display in the queue

        } else {

            double last_duration, duration, delay;

            /* dequeue the picture */

            vp = &is->pictq[is->pictq_rindex];

 

            if (vp->serial != is->videoq.serial) {

                pictq_next_picture(is);

                redisplay = 0;

                goto retry;

            }

 

            if (is->paused)

                goto display;

 

            /* compute nominal last_duration */

            last_duration = vp->pts - is->frame_last_pts;

            if (!isnan(last_duration) && last_duration > 0 && last_duration < is->max_frame_duration) {

                /* if duration of the last frame was sane, update last_duration in video state */

                is->frame_last_duration = last_duration;

            }

            if (redisplay)

                delay = 0.0;

            else

                delay = compute_target_delay(is->frame_last_duration, is);

 

            time= av_gettime()/1000000.0;