@@ -12,7 +12,7 @@ doc/*.html

 doc/*.pod

 doxy

 ffmpeg

-ffplay

+avplay

 ffprobe

 ffserver

 libavcodec/*_tablegen

@@ -5,6 +5,7 @@ releases are sorted from youngest to oldest.

 version <next>:

 - BWF muxer

 - Flash Screen Video 2 decoder

+- ffplay renamed to avplay

 version 0.7:

@@ -53,7 +53,7 @@ COMPILE_S = $(call COMPILE,AS)

 %.c %.h: TAG = GEN

 PROGS-$(CONFIG_FFMPEG)   += ffmpeg

-PROGS-$(CONFIG_FFPLAY)   += ffplay

+PROGS-$(CONFIG_AVPLAY)   += avplay

 PROGS-$(CONFIG_FFPROBE)  += ffprobe

 PROGS-$(CONFIG_FFSERVER) += ffserver

@@ -64,7 +64,7 @@ HOSTPROGS  := $(TESTTOOLS:%=tests/%)

 TOOLS       = qt-faststart trasher

 TOOLS-$(CONFIG_ZLIB) += cws2fws

-BASENAMES   = ffmpeg ffplay ffprobe ffserver

+BASENAMES   = ffmpeg avplay ffprobe ffserver

 ALLPROGS    = $(BASENAMES:%=%$(EXESUF))

 ALLMANPAGES = $(BASENAMES:%=%.1)

@@ -116,8 +116,8 @@ endef

 $(foreach D,$(FFLIBS),$(eval $(call DOSUBDIR,lib$(D))))

-ffplay.o: CFLAGS += $(SDL_CFLAGS)

-ffplay$(EXESUF): FF_EXTRALIBS += $(SDL_LIBS)

+avplay.o: CFLAGS += $(SDL_CFLAGS)

+avplay$(EXESUF): FF_EXTRALIBS += $(SDL_LIBS)

 ffserver$(EXESUF): LDFLAGS += $(FFSERVERLDFLAGS)

 $(PROGS): %$(EXESUF): %.o cmdutils.o $(FF_DEP_LIBS)

new file mode 100644

@@ -0,0 +1,3071 @@

+/*

+ * avplay : Simple Media Player based on the Libav libraries

+ * Copyright (c) 2003 Fabrice Bellard

+ *

+ * This file is part of Libav.

+ *

+ * Libav is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * Libav is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "config.h"

+#include <inttypes.h>

+#include <math.h>

+#include <limits.h>

+#include "libavutil/avstring.h"

+#include "libavutil/colorspace.h"

+#include "libavutil/mathematics.h"

+#include "libavutil/pixdesc.h"

+#include "libavutil/imgutils.h"

+#include "libavutil/dict.h"

+#include "libavutil/parseutils.h"

+#include "libavutil/samplefmt.h"

+#include "libavformat/avformat.h"

+#include "libavdevice/avdevice.h"

+#include "libswscale/swscale.h"

+#include "libavcodec/audioconvert.h"

+#include "libavutil/opt.h"

+#include "libavcodec/avfft.h"

+

+#if CONFIG_AVFILTER

+# include "libavfilter/avfilter.h"

+# include "libavfilter/avfiltergraph.h"

+#endif

+

+#include "cmdutils.h"

+

+#include <SDL.h>

+#include <SDL_thread.h>

+

+#ifdef __MINGW32__

+#undef main /* We don't want SDL to override our main() */

+#endif

+

+#include <unistd.h>

+#include <assert.h>

+

+const char program_name[] = "avplay";

+const int program_birth_year = 2003;

+

+#define MAX_QUEUE_SIZE (15 * 1024 * 1024)

+#define MIN_AUDIOQ_SIZE (20 * 16 * 1024)

+#define MIN_FRAMES 5

+

+/* SDL audio buffer size, in samples. Should be small to have precise

+   A/V sync as SDL does not have hardware buffer fullness info. */

+#define SDL_AUDIO_BUFFER_SIZE 1024

+

+/* no AV sync correction is done if below the AV sync threshold */

+#define AV_SYNC_THRESHOLD 0.01

+/* no AV correction is done if too big error */

+#define AV_NOSYNC_THRESHOLD 10.0

+

+#define FRAME_SKIP_FACTOR 0.05

+

+/* maximum audio speed change to get correct sync */

+#define SAMPLE_CORRECTION_PERCENT_MAX 10

+

+/* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */

+#define AUDIO_DIFF_AVG_NB   20

+

+/* NOTE: the size must be big enough to compensate the hardware audio buffersize size */

+#define SAMPLE_ARRAY_SIZE (2*65536)

+

+static int sws_flags = SWS_BICUBIC;

+

+typedef struct PacketQueue {

+    AVPacketList *first_pkt, *last_pkt;

+    int nb_packets;

+    int size;

+    int abort_request;

+    SDL_mutex *mutex;

+    SDL_cond *cond;

+} PacketQueue;

+

+#define VIDEO_PICTURE_QUEUE_SIZE 2

+#define SUBPICTURE_QUEUE_SIZE 4

+

+typedef struct VideoPicture {

+    double pts;                                  ///<presentation time stamp for this picture

+    double target_clock;                         ///<av_gettime() time at which this should be displayed ideally

+    int64_t pos;                                 ///<byte position in file

+    SDL_Overlay *bmp;

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

+    int allocated;

+    enum PixelFormat pix_fmt;

+

+#if CONFIG_AVFILTER

+    AVFilterBufferRef *picref;

+#endif

+} VideoPicture;

+

+typedef struct SubPicture {

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

+    AVSubtitle sub;

+} SubPicture;

+

+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 *parse_tid;

+    SDL_Thread *video_tid;

+    SDL_Thread *refresh_tid;

+    AVInputFormat *iformat;

+    int no_background;

+    int abort_request;

+    int paused;

+    int last_paused;

+    int seek_req;

+    int seek_flags;

+    int64_t seek_pos;

+    int64_t seek_rel;

+    int read_pause_return;

+    AVFormatContext *ic;

+    int dtg_active_format;

+

+    int audio_stream;

+

+    int av_sync_type;

+    double external_clock; /* external clock base */

+    int64_t external_clock_time;

+

+    double audio_clock;

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

+    /* samples output by the codec. we reserve more space for avsync

+       compensation */

+    DECLARE_ALIGNED(16,uint8_t,audio_buf1)[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

+    DECLARE_ALIGNED(16,uint8_t,audio_buf2)[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

+    uint8_t *audio_buf;

+    unsigned int audio_buf_size; /* in bytes */

+    int audio_buf_index; /* in bytes */

+    AVPacket audio_pkt_temp;

+    AVPacket audio_pkt;

+    enum AVSampleFormat audio_src_fmt;

+    AVAudioConvert *reformat_ctx;

+

+    int show_audio; /* if true, display audio samples */

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

+

+    SDL_Thread *subtitle_tid;

+    int subtitle_stream;

+    int subtitle_stream_changed;

+    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_delay;

+    double video_clock;                          ///<pts of last decoded frame / predicted pts of next decoded frame

+    int video_stream;

+    AVStream *video_st;

+    PacketQueue videoq;

+    double video_current_pts;                    ///<current displayed pts (different from video_clock if frame fifos are used)

+    double video_current_pts_drift;              ///<video_current_pts - time (av_gettime) at which we updated video_current_pts - used to have running video pts

+    int64_t video_current_pos;                   ///<current displayed file pos

+    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

+    int pictq_size, pictq_rindex, pictq_windex;

+    SDL_mutex *pictq_mutex;

+    SDL_cond *pictq_cond;

+#if !CONFIG_AVFILTER

+    struct SwsContext *img_convert_ctx;

+#endif

+

+    //    QETimer *video_timer;

+    char filename[1024];

+    int width, height, xleft, ytop;

+

+    PtsCorrectionContext pts_ctx;

+

+#if CONFIG_AVFILTER

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

+#endif

+

+    float skip_frames;

+    float skip_frames_index;

+    int refresh;

+} VideoState;

+

+static void show_help(void);

+

+/* options specified by the user */

+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 screen_width = 0;

+static int screen_height = 0;

+static int audio_disable;

+static int video_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 debug = 0;

+static int debug_mv = 0;

+static int step = 0;

+static int thread_count = 1;

+static int workaround_bugs = 1;

+static int fast = 0;

+static int genpts = 0;

+static int lowres = 0;

+static int idct = FF_IDCT_AUTO;

+static enum AVDiscard skip_frame= AVDISCARD_DEFAULT;

+static enum AVDiscard skip_idct= AVDISCARD_DEFAULT;

+static enum AVDiscard skip_loop_filter= AVDISCARD_DEFAULT;

+static int error_recognition = FF_ER_CAREFUL;

+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 rdftspeed=20;

+#if CONFIG_AVFILTER

+static char *vfilters = NULL;

+#endif

+

+/* current context */

+static int is_full_screen;

+static VideoState *cur_stream;

+static int64_t audio_callback_time;

+

+static AVPacket flush_pkt;

+

+#define FF_ALLOC_EVENT   (SDL_USEREVENT)

+#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

+#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)

+

+static SDL_Surface *screen;

+

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

+

+/* packet queue handling */

+static void packet_queue_init(PacketQueue *q)

+{

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

+    q->mutex = SDL_CreateMutex();

+    q->cond = SDL_CreateCond();

+    packet_queue_put(q, &flush_pkt);

+}

+

+static void packet_queue_flush(PacketQueue *q)

+{

+    AVPacketList *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_end(PacketQueue *q)

+{

+    packet_queue_flush(q);

+    SDL_DestroyMutex(q->mutex);

+    SDL_DestroyCond(q->cond);

+}

+

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

+{

+    AVPacketList *pkt1;

+

+    /* duplicate the packet */

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

+        return -1;

+

+    pkt1 = av_malloc(sizeof(AVPacketList));

+    if (!pkt1)

+        return -1;

+    pkt1->pkt = *pkt;

+    pkt1->next = NULL;

+

+

+    SDL_LockMutex(q->mutex);

+

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

+

+    SDL_UnlockMutex(q->mutex);

+    return 0;

+}

+

+static void packet_queue_abort(PacketQueue *q)

+{

+    SDL_LockMutex(q->mutex);

+

+    q->abort_request = 1;

+

+    SDL_CondSignal(q->cond);

+

+    SDL_UnlockMutex(q->mutex);

+}

+

+/* return < 0 if aborted, 0 if no packet and > 0 if packet.  */

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

+{

+    AVPacketList *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;

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

+{

+    SDL_Rect rect;

+    rect.x = x;

+    rect.y = y;

+    rect.w = w;

+    rect.h = h;

+    SDL_FillRect(screen, &rect, color);

+}

+

+#define ALPHA_BLEND(a, oldp, newp, s)\

+((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))

+

+#define RGBA_IN(r, g, b, a, s)\

+{\

+    unsigned int v = ((const uint32_t *)(s))[0];\

+    a = (v >> 24) & 0xff;\

+    r = (v >> 16) & 0xff;\

+    g = (v >> 8) & 0xff;\

+    b = v & 0xff;\

+}

+

+#define YUVA_IN(y, u, v, a, s, pal)\

+{\

+    unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\

+    a = (val >> 24) & 0xff;\

+    y = (val >> 16) & 0xff;\

+    u = (val >> 8) & 0xff;\

+    v = val & 0xff;\

+}

+

+#define YUVA_OUT(d, y, u, v, a)\

+{\

+    ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\

+}

+

+

+#define BPP 1

+

+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_subpicture(SubPicture *sp)

+{

+    avsubtitle_free(&sp->sub);

+}

+

+static void video_image_display(VideoState *is)

+{

+    VideoPicture *vp;

+    SubPicture *sp;

+    AVPicture pict;

+    float aspect_ratio;

+    int width, height, x, y;

+    SDL_Rect rect;

+    int i;

+

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

+    if (vp->bmp) {

+#if CONFIG_AVFILTER

+         if (vp->picref->video->pixel_aspect.num == 0)

+             aspect_ratio = 0;

+         else

+             aspect_ratio = av_q2d(vp->picref->video->pixel_aspect);

+#else

+

+        /* XXX: use variable in the frame */

+        if (is->video_st->sample_aspect_ratio.num)

+            aspect_ratio = av_q2d(is->video_st->sample_aspect_ratio);

+        else if (is->video_st->codec->sample_aspect_ratio.num)

+            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio);

+        else

+            aspect_ratio = 0;

+#endif

+        if (aspect_ratio <= 0.0)

+            aspect_ratio = 1.0;

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

+

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

+                }

+            }

+        }

+

+

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

+        height = is->height;

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

+        if (width > is->width) {

+            width = is->width;

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

+        }

+        x = (is->width - width) / 2;

+        y = (is->height - height) / 2;

+        is->no_background = 0;

+        rect.x = is->xleft + x;

+        rect.y = is->ytop  + y;

+        rect.w = width;

+        rect.h = height;

+        SDL_DisplayYUVOverlay(vp->bmp, &rect);

+    }

+}

+

+/* get the current audio output buffer size, in samples. With SDL, we

+   cannot have a precise information */

+static int audio_write_get_buf_size(VideoState *is)

+{

+    return is->audio_buf_size - is->audio_buf_index;

+}

+

+static inline int compute_mod(int a, int b)

+{

+    a = a % b;

+    if (a >= 0)

+        return a;

+    else

+        return 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;

+    int16_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_st->codec->channels;

+    nb_display_channels = channels;

+    if (!s->paused) {

+        int data_used= s->show_audio==1 ? s->width : (2*nb_freq);

+        n = 2 * channels;

+        delay = audio_write_get_buf_size(s);

+        delay /= n;

+

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

+           the last buffer computation */

+        if (audio_callback_time) {

+            time_diff = av_gettime() - audio_callback_time;

+            delay -= (time_diff * s->audio_st->codec->sample_rate) / 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_audio==1){

+            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_audio==1){

+        fill_rectangle(screen,

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

+                       bgcolor);

+

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

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

+        }

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