@@ -16,18 +16,22 @@ endif

 ifeq ($(CONFIG_WIN32),yes)

 EXE=.exe

-PROG=ffmpeg$(EXE)

 else

 ifeq ($(CONFIG_OS2),yes)

 EXE=.exe

-PROG=ffmpeg$(EXE)

 else

 EXE=

-PROG=ffmpeg ffplay

-ifeq ($(CONFIG_FFSERVER),yes)

-PROG+=ffserver

 endif

 endif

+

+PROG=ffmpeg$(EXE)

+

+ifeq ($(CONFIG_FFSERVER),yes)

+PROG+=ffserver$(EXE)

+endif

+

+ifeq ($(CONFIG_FFPLAY),yes)

+PROG+=ffplay$(EXE)

 endif

 ifeq ($(CONFIG_AUDIO_BEOS),yes)

@@ -67,7 +71,7 @@ else

 TEST=test

 endif

-OBJS = ffmpeg.o ffserver.o

+OBJS = ffmpeg.o ffserver.o cmdutils.o ffplay.o

 SRCS = $(OBJS:.o=.c) $(ASM_OBJS:.o=.s)

 FFLIBS = -L./libavformat -lavformat -L./libavcodec -lavcodec

@@ -77,9 +81,8 @@ lib: $(AMRLIBS)

 	$(MAKE) -C libavcodec all

 	$(MAKE) -C libavformat all

-

-ffmpeg_g$(EXE): ffmpeg.o .libs

-	$(CC) $(LDFLAGS) -o $@ ffmpeg.o $(FFLIBS) $(EXTRALIBS)

+ffmpeg_g$(EXE): ffmpeg.o cmdutils.o .libs

+	$(CC) $(LDFLAGS) -o $@ ffmpeg.o cmdutils.o $(FFLIBS) $(EXTRALIBS)

 ffmpeg$(EXE): ffmpeg_g$(EXE)

 	cp -p $< $@

@@ -88,8 +91,15 @@ ffmpeg$(EXE): ffmpeg_g$(EXE)

 ffserver$(EXE): ffserver.o .libs

 	$(CC) $(LDFLAGS) $(FFSLDFLAGS) -o $@ ffserver.o $(FFLIBS) $(EXTRALIBS) 

-ffplay: ffmpeg$(EXE)

-	ln -sf $< $@

+ffplay_g$(EXE): ffplay.o cmdutils.o .libs

+	$(CC) $(LDFLAGS) -o $@ ffplay.o cmdutils.o $(FFLIBS) $(EXTRALIBS) $(SDL_LIBS)

+

+ffplay$(EXE): ffplay_g$(EXE)

+	cp -p $< $@

+	$(STRIP) $@

+

+ffplay.o: ffplay.c

+	$(CC) $(CFLAGS) $(SDL_CFLAGS) -c -o $@ $< 

 %.o: %.c

 	$(CC) $(CFLAGS) -c -o $@ $< 

@@ -101,7 +111,6 @@ install: all $(INSTALLVHOOK)

 	$(MAKE) -C libavcodec install

 	install -d $(prefix)/bin

 	install -c -s -m 755 $(PROG) $(prefix)/bin

-	ln -sf ffmpeg $(prefix)/bin/ffplay 

 install-vhook: $(prefix)/lib/vhook

 	$(MAKE) -C vhook install INSTDIR=$(prefix)/lib/vhook

@@ -133,7 +142,7 @@ clean: $(CLEANVHOOK)

 	$(MAKE) -C libavcodec clean

 	$(MAKE) -C libavformat clean

 	$(MAKE) -C tests clean

-	rm -f *.o *.d *~ .libs .depend gmon.out TAGS ffmpeg_g$(EXE) $(PROG) 

+	rm -f *.o *.d *~ .libs .depend gmon.out TAGS ffmpeg_g$(EXE) ffplay_g$(EXE) $(PROG) 

 clean-vhook:

 	$(MAKE) -C vhook clean

new file mode 100644

@@ -0,0 +1,120 @@

+/*

+ * Various utilities for command line tools

+ * Copyright (c) 2000-2003 Fabrice Bellard

+ *

+ * This library 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 of the License, or (at your option) any later version.

+ *

+ * This library 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 this library; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ */

+#include <stdlib.h>

+#include <stdio.h>

+#include <string.h>

+

+#include "common.h"

+#include "avformat.h"

+

+#include "cmdutils.h"

+

+void show_help_options(const OptionDef *options)

+{

+    const OptionDef *po;

+    int i, expert, first;

+

+    printf("Main options are:\n");

+    for(i=0;i<2;i++) {

+        first = 1;

+        for(po = options; po->name != NULL; po++) {

+            char buf[64];

+            expert = (po->flags & OPT_EXPERT) != 0;

+            if (expert == i) {

+                if (expert && first) {

+                    printf("\nAdvanced options are:\n");

+                    first = 0;

+                }

+                strcpy(buf, po->name);

+                if (po->flags & HAS_ARG) {

+                    strcat(buf, " ");

+                    strcat(buf, po->argname);

+                }

+                printf("-%-17s  %s\n", buf, po->help);

+            }

+        }

+    }

+}

+

+void parse_options(int argc, char **argv, const OptionDef *options)

+{

+    const char *opt, *arg;

+    int optindex;

+    const OptionDef *po;

+

+    /* parse options */

+    optindex = 1;

+    while (optindex < argc) {

+        opt = argv[optindex++];

+        

+        if (opt[0] == '-' && opt[1] != '\0') {

+            po = options;

+            while (po->name != NULL) {

+                if (!strcmp(opt + 1, po->name))

+                    break;

+                po++;

+            }

+            if (!po->name) {

+                fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);

+                exit(1);

+            }

+            arg = NULL;

+            if (po->flags & HAS_ARG) {

+                arg = argv[optindex++];

+                if (!arg) {

+                    fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);

+                    exit(1);

+                }

+            }

+            if (po->flags & OPT_STRING) {

+                char *str;

+                str = strdup(arg);

+                *po->u.str_arg = str;

+            } else if (po->flags & OPT_BOOL) {

+                *po->u.int_arg = 1;

+            } else {

+		po->u.func_arg(arg);

+            }

+        } else {

+            parse_arg_file(opt);

+        }

+    }

+}

+

+void print_error(const char *filename, int err)

+{

+    switch(err) {

+    case AVERROR_NUMEXPECTED:

+        fprintf(stderr, "%s: Incorrect image filename syntax.\n"

+                "Use '%%d' to specify the image number:\n"

+                "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"

+                "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n", 

+                filename);

+        break;

+    case AVERROR_INVALIDDATA:

+        fprintf(stderr, "%s: Error while parsing header\n", filename);

+        break;

+    case AVERROR_NOFMT:

+        fprintf(stderr, "%s: Unknown format\n", filename);

+        break;

+    default:

+        fprintf(stderr, "%s: Error while opening file\n", filename);

+        break;

+    }

+}

new file mode 100644

@@ -0,0 +1,25 @@

+#ifndef _CMD_UTILS_H

+#define _CMD_UTILS_H

+

+typedef struct {

+    const char *name;

+    int flags;

+#define HAS_ARG    0x0001

+#define OPT_BOOL   0x0002

+#define OPT_EXPERT 0x0004

+#define OPT_STRING 0x0008

+    union {

+        void (*func_arg)(const char *);

+        int *int_arg;

+        char **str_arg;

+    } u;

+    const char *help;

+    const char *argname;

+} OptionDef;

+

+void show_help_options(const OptionDef *options);

+void parse_options(int argc, char **argv, const OptionDef *options);

+void parse_arg_file(const char *filename);

+void print_error(const char *filename, int err);

+

+#endif /* _CMD_UTILS_H */

@@ -1,6 +1,6 @@

 /*

  * FFmpeg main 

- * Copyright (c) 2000, 2001, 2002 Fabrice Bellard

+ * Copyright (c) 2000-2003 Fabrice Bellard

  *

  * This library is free software; you can redistribute it and/or

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

@@ -40,28 +40,14 @@

 #include <time.h>

 #include <ctype.h>

+#include "cmdutils.h"

+

 #if !defined(INFINITY) && defined(HUGE_VAL)

 #define INFINITY HUGE_VAL

 #endif

 #define MAXINT64 int64_t_C(0x7fffffffffffffff)

-typedef struct {

-    const char *name;

-    int flags;

-#define HAS_ARG    0x0001

-#define OPT_BOOL   0x0002

-#define OPT_EXPERT 0x0004

-#define OPT_STRING 0x0008

-    union {

-        void (*func_arg)(const char *);

-        int *int_arg;

-        char **str_arg;

-    } u;

-    const char *help;

-    const char *argname;

-} OptionDef;

-

 /* select an input stream for an output stream */

 typedef struct AVStreamMap {

     int file_index;

@@ -133,7 +119,6 @@ static int use_4mv = 0;

 static int use_aic = 0;

 static int use_umv = 0;

 /* /Fx */

-static int use_h263p_extra = 0;

 static int do_deinterlace = 0;

 static int workaround_bugs = FF_BUG_AUTODETECT;

 static int error_resilience = 2;

@@ -161,7 +146,6 @@ static char *str_copyright = NULL;

 static char *str_comment = NULL;

 static int do_benchmark = 0;

 static int do_hex_dump = 0;

-static int do_play = 0;

 static int do_psnr = 0;

 static int do_vstats = 0;

 static int do_pass = 0;

@@ -1134,11 +1118,7 @@ static int av_encode(AVFormatContext **output_files,

     }

 #ifndef CONFIG_WIN32

-    if (!do_play) {

-        fprintf(stderr, "Press [q] to stop encoding\n");

-    } else {

-        fprintf(stderr, "Press [q] to stop playing\n");

-    }

+    fprintf(stderr, "Press [q] to stop encoding\n");

 #endif

     term_init();

@@ -1998,28 +1978,6 @@ static void opt_recording_time(const char *arg)

     recording_time = parse_date(arg, 1);

 }

-static void print_error(const char *filename, int err)

-{

-    switch(err) {

-    case AVERROR_NUMEXPECTED:

-        fprintf(stderr, "%s: Incorrect image filename syntax.\n"

-                "Use '%%d' to specify the image number:\n"

-                "  for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"

-                "  for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n", 

-                filename);

-        break;

-    case AVERROR_INVALIDDATA:

-        fprintf(stderr, "%s: Error while parsing header\n", filename);

-        break;

-    case AVERROR_NOFMT:

-        fprintf(stderr, "%s: Unknown format\n", filename);

-        break;

-    default:

-        fprintf(stderr, "%s: Error while opening file\n", filename);

-        break;

-    }

-}

-

 static void opt_input_file(const char *filename)

 {

     AVFormatContext *ic;

@@ -2524,40 +2482,6 @@ static void prepare_grab(void)

     }

 }

-/* open the necessary output devices for playing */

-static void prepare_play(void)

-{

-    int has_video, has_audio;

-    

-    check_audio_video_inputs(&has_video, &has_audio);

-        

-    /* manual disable */

-    if (audio_disable) {

-        has_audio = 0;

-    }

-    if (video_disable) {

-        has_video = 0;

-    }

-        

-    if (has_audio) {

-        file_oformat = guess_format("audio_device", NULL, NULL);

-        if (!file_oformat) {

-            fprintf(stderr, "Could not find audio device\n");

-            exit(1);

-        }

-        opt_output_file(audio_device?audio_device:"/dev/dsp");

-    }

-

-    if (has_video) {

-        file_oformat = guess_format("framebuffer_device", NULL, NULL);

-        if (!file_oformat) {

-            fprintf(stderr, "Could not find framebuffer device\n");

-            exit(1);

-        }

-        opt_output_file("");

-    }

-}

-

 /* same option as mencoder */

 static void opt_pass(const char *pass_str)

 {

@@ -2668,47 +2592,6 @@ static void show_formats(void)

     exit(1);

 }

-void show_help(void)

-{

-    const char *prog;

-    const OptionDef *po;

-    int i, expert;

-    

-    prog = do_play ? "ffplay" : "ffmpeg";

-

-    printf("%s version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n",

-           prog);

-    

-    if (!do_play) {

-        printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"

-               "Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n");

-    } else {

-        printf("usage: ffplay [options] input_file...\n"

-               "Simple audio player\n");

-    }

-           

-    printf("\n"

-           "Main options are:\n");

-    for(i=0;i<2;i++) {

-        if (i == 1)

-            printf("\nAdvanced options are:\n");

-        for(po = options; po->name != NULL; po++) {

-            char buf[64];

-            expert = (po->flags & OPT_EXPERT) != 0;

-            if (expert == i) {

-                strcpy(buf, po->name);

-                if (po->flags & HAS_ARG) {

-                    strcat(buf, " ");

-                    strcat(buf, po->argname);

-                }

-                printf("-%-17s  %s\n", buf, po->help);

-            }

-        }

-    }

-

-    exit(1);

-}

-

 const OptionDef options[] = {

     { "L", 0, {(void*)show_licence}, "show license" },

     { "h", 0, {(void*)show_help}, "show help" },

@@ -2803,83 +2686,42 @@ const OptionDef options[] = {

     { NULL, },

 };

+void show_help(void)

+{

+    printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n");

+    printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"

+           "Hyper fast Audio and Video encoder\n");

+    printf("\n");

+    show_help_options(options);

+    exit(1);

+}

+

+void parse_arg_file(const char *filename)

+{

+    opt_output_file(filename);

+}

+

 int main(int argc, char **argv)

 {

-    int optindex, i;

-    const char *opt, *arg;

-    const OptionDef *po;

+    int i;

     int64_t ti;

     av_register_all();

-    /* detect if invoked as player */

-    i = strlen(argv[0]);

-    if (i >= 6 && !strcmp(argv[0] + i - 6, "ffplay"))

-        do_play = 1;

-

     if (argc <= 1)

         show_help();

     /* parse options */

-    optindex = 1;

-    while (optindex < argc) {

-        opt = argv[optindex++];

-        

-        if (opt[0] == '-' && opt[1] != '\0') {

-            po = options;

-            while (po->name != NULL) {

-                if (!strcmp(opt + 1, po->name))

-                    break;

-                po++;

-            }

-            if (!po->name) {

-                fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);

-                exit(1);

-            }

-            arg = NULL;

-            if (po->flags & HAS_ARG) {

-                arg = argv[optindex++];

-                if (!arg) {

-                    fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);

-                    exit(1);

-                }

-            }

-            if (po->flags & OPT_STRING) {

-                char *str;

-                str = av_strdup(arg);

-                *po->u.str_arg = str;

-            } else if (po->flags & OPT_BOOL) {

-                *po->u.int_arg = 1;

-            } else {

-		po->u.func_arg(arg);

-            }

-        } else {

-            if (!do_play) {

-                opt_output_file(opt);

-            } else {

-                opt_input_file(opt);

-            }

-        }

-    }

+    parse_options(argc, argv, options);

-

-    if (!do_play) {

-        /* file converter / grab */

-        if (nb_output_files <= 0) {

-            fprintf(stderr, "Must supply at least one output file\n");

-            exit(1);

-        }

-        

-        if (nb_input_files == 0) {

-            prepare_grab();

-        }

-    } else {

-        /* player */

-        if (nb_input_files <= 0) {

-            fprintf(stderr, "Must supply at least one input file\n");

-            exit(1);

-        }

-        prepare_play();

+    /* file converter / grab */

+    if (nb_output_files <= 0) {

+        fprintf(stderr, "Must supply at least one output file\n");

+        exit(1);

+    }

+    

+    if (nb_input_files == 0) {

+        prepare_grab();

     }

     ti = getutime();

new file mode 100644

@@ -0,0 +1,1397 @@

+/*

+ * FFplay : Simple Media Player based on the ffmpeg libraries

+ * Copyright (c) 2003 Fabrice Bellard

+ *

+ * This library 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 of the License, or (at your option) any later version.

+ *

+ * This library 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 this library; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ */

+#define HAVE_AV_CONFIG_H

+#include "common.h"

+#include "avformat.h"

+

+#include "cmdutils.h"

+

+#include <SDL.h>

+#include <SDL_thread.h>

+

+#if defined(__linux__)

+#define HAVE_X11

+#endif

+

+#ifdef HAVE_X11

+#include <X11/Xlib.h>

+#endif

+

+#define MAX_VIDEOQ_SIZE (5 * 256 * 1024)

+#define MAX_AUDIOQ_SIZE (5 * 16 * 1024)

+

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

+#define SAMPLE_ARRAY_SIZE (2*65536)

+

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

+

+typedef struct VideoPicture {

+    int delay; /* delay before showing the next picture */

+    SDL_Overlay *bmp;

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

+    int allocated;

+} VideoPicture;

+

+enum {

+    AV_SYNC_AUDIO_MASTER, /* default choice */

+    AV_SYNC_VIDEO_MASTER,

+    AV_SYNC_EXTERNAL_CLOCK, /* if external clock, then you must update external_clock yourself */

+};

+

+typedef struct VideoState {

+    SDL_Thread *parse_tid;

+    SDL_Thread *video_tid;

+    int no_background;

+    int abort_request;

+    int paused;

+    AVFormatContext *ic;

+    int dtg_active_format;

+

+    int audio_stream;

+    

+    int av_sync_type;

+    double external_clock; /* external clock */

+

+    double audio_clock;  /* current audio clock value */

+    AVStream *audio_st;

+    PacketQueue audioq;

+    int audio_hw_buf_size;

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

+       compensation */

+    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]; 

+    int audio_buf_size; /* in bytes */

+    int audio_buf_index; /* in bytes */

+    AVPacket audio_pkt;

+    uint8_t *audio_pkt_data;

+    int audio_pkt_size;

+    int64_t audio_pkt_ipts;

+    

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

+    int16_t sample_array[SAMPLE_ARRAY_SIZE];

+    int sample_array_index;

+    

+    double video_clock; /* current video clock value */

+    int video_stream;

+    AVStream *video_st;

+    PacketQueue videoq;

+

+    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

+    int pictq_size, pictq_rindex, pictq_windex;

+    SDL_mutex *pictq_mutex;

+    SDL_cond *pictq_cond;

+    

+    //    QETimer *video_timer;

+    char filename[1024];

+    int width, height, xleft, ytop;

+} VideoState;

+

+void show_help(void);

+int audio_write_get_buf_size(VideoState *is);

+

+/* options specified by the user */

+static AVInputFormat *file_iformat;

+static const char *input_filename;

+static int fs_screen_width;

+static int fs_screen_height;

+static int screen_width = 640;

+static int screen_height = 480;

+static int audio_disable;

+static int video_disable;

+static int display_disable;

+static int show_status;

+

+/* current context */

+static int is_full_screen;

+static VideoState *cur_stream;

+static int16_t audio_callback_time;

+

+#define FF_ALLOC_EVENT   (SDL_USEREVENT)

+#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

+

+SDL_Surface *screen;

+

+/* packet queue handling */

+static void packet_queue_init(PacketQueue *q)

+{

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

+    q->mutex = SDL_CreateMutex();

+    q->cond = SDL_CreateCond();

+}

+

+static void packet_queue_end(PacketQueue *q)

+{

+    AVPacketList *pkt, *pkt1;

+

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

+        pkt1 = pkt->next;

+        av_free_packet(&pkt->pkt);

+    }

+    SDL_DestroyMutex(q->mutex);

+    SDL_DestroyCond(q->cond);

+}

+

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

+{

+    AVPacketList *pkt1;

+

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

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

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

+}

+

+#if 0

+/* draw only the border of a rectangle */

+void fill_border(VideoState *s, int x, int y, int w, int h, int color)

+{

+    int w1, w2, h1, h2;

+

+    /* fill the background */

+    w1 = x;

+    if (w1 < 0)

+        w1 = 0;

+    w2 = s->width - (x + w);

+    if (w2 < 0)

+        w2 = 0;

+    h1 = y;

+    if (h1 < 0)

+        h1 = 0;

+    h2 = s->height - (y + h);

+    if (h2 < 0)

+        h2 = 0;

+    fill_rectangle(screen, 

+                   s->xleft, s->ytop, 

+                   w1, s->height, 

+                   color);

+    fill_rectangle(screen, 

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

+                   w2, s->height, 

+                   color);

+    fill_rectangle(screen, 

+                   s->xleft + w1, s->ytop, 

+                   s->width - w1 - w2, h1, 

+                   color);

+    fill_rectangle(screen, 

+                   s->xleft + w1, s->ytop + s->height - h2,

+                   s->width - w1 - w2, h2,

+                   color);

+}

+#endif

+

+static void video_image_display(VideoState *is)

+{

+    VideoPicture *vp;

+    float aspect_ratio;

+    int width, height, x, y;

+    SDL_Rect rect;

+

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

+    if (vp->bmp) {

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

+        aspect_ratio = is->video_st->codec.aspect_ratio;

+        if (aspect_ratio <= 0.0)

+            aspect_ratio = (float)is->video_st->codec.width / 

+                (float)is->video_st->codec.height;

+        /* if an active format is indicated, then it overrides the

+           mpeg format */

+#if 0

+        if (is->video_st->codec.dtg_active_format != is->dtg_active_format) {

+            is->dtg_active_format = is->video_st->codec.dtg_active_format;

+            printf("dtg_active_format=%d\n", is->dtg_active_format);

+        }

+#endif

+#if 0

+        switch(is->video_st->codec.dtg_active_format) {

+        case FF_DTG_AFD_SAME:

+        default:

+            /* nothing to do */

+            break;

+        case FF_DTG_AFD_4_3:

+            aspect_ratio = 4.0 / 3.0;

+            break;

+        case FF_DTG_AFD_16_9:

+            aspect_ratio = 16.0 / 9.0;

+            break;

+        case FF_DTG_AFD_14_9:

+            aspect_ratio = 14.0 / 9.0;

+            break;

+        case FF_DTG_AFD_4_3_SP_14_9:

+            aspect_ratio = 14.0 / 9.0;

+            break;

+        case FF_DTG_AFD_16_9_SP_14_9:

+            aspect_ratio = 14.0 / 9.0;

+            break;

+        case FF_DTG_AFD_SP_4_3:

+            aspect_ratio = 4.0 / 3.0;

+            break;

+        }

+#endif

+

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

+        height = is->height;

+        width = ((int)rint(height * aspect_ratio)) & -3;

+        if (width > is->width) {

+            width = is->width;

+            height = ((int)rint(width / aspect_ratio)) & -3;

+        }

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

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

+        if (!is->no_background) {

+            /* fill the background */

+            //            fill_border(is, x, y, width, height, QERGB(0x00, 0x00, 0x00));

+        } else {

+            is->no_background = 0;

+        }

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

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

+        rect.w = width;

+        rect.h = height;

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

+    } else {

+#if 0

+        fill_rectangle(screen, 

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