Make parse_date return INT64_MIN in case of unparsable input.
[ffmpeg.git] / ffplay.c
index 720ce32..6ec1bcb 100644 (file)
--- a/ffplay.c
+++ b/ffplay.c
@@ -2,48 +2,40 @@
  * 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
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * This library is distributed in the hope that it will be useful,
+ * FFmpeg 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
+ * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
-#define HAVE_AV_CONFIG_H
+
+#include <math.h>
+#include <limits.h>
 #include "avformat.h"
+#include "swscale.h"
+#include "avstring.h"
 
+#include "version.h"
 #include "cmdutils.h"
 
 #include <SDL.h>
 #include <SDL_thread.h>
 
-#ifdef CONFIG_WIN32
+#ifdef __MINGW32__
 #undef main /* We don't want SDL to override our main() */
 #endif
 
-#ifdef CONFIG_OS2
-#define INCL_DOS
- #include <os2.h>
- #include <stdio.h>
-
- void MorphToPM()
- {
-   PPIB pib;
-   PTIB tib;
-
-   DosGetInfoBlocks(&tib, &pib);
-
-   // Change flag from VIO to PM:
-   if (pib->pib_ultype==2) pib->pib_ultype = 3;
- }
-#endif
+#undef exit
 
 //#define DEBUG_SYNC
 
@@ -69,6 +61,8 @@
 /* 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;
@@ -129,7 +123,7 @@ typedef struct VideoState {
     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];
+    DECLARE_ALIGNED(16,uint8_t,audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2]);
     unsigned int audio_buf_size; /* in bytes */
     int audio_buf_index; /* in bytes */
     AVPacket audio_pkt;
@@ -165,10 +159,6 @@ typedef struct VideoState {
     SDL_mutex *pictq_mutex;
     SDL_cond *pictq_cond;
 
-    SDL_mutex *video_decoder_mutex;
-    SDL_mutex *audio_decoder_mutex;
-    SDL_mutex *subtitle_decoder_mutex;
-
     //    QETimer *video_timer;
     char filename[1024];
     int width, height, xleft, ytop;
@@ -179,14 +169,19 @@ static int audio_write_get_buf_size(VideoState *is);
 
 /* options specified by the user */
 static AVInputFormat *file_iformat;
-static AVImageFormat *image_format;
 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 screen_width = 0;
+static int screen_height = 0;
+static int frame_width = 0;
+static int frame_height = 0;
+static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 static int audio_disable;
 static int video_disable;
+static int wanted_audio_stream= 0;
+static int wanted_video_stream= 0;
+static int seek_by_bytes;
 static int display_disable;
 static int show_status;
 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
@@ -205,12 +200,15 @@ static enum AVDiscard skip_idct= AVDISCARD_DEFAULT;
 static enum AVDiscard skip_loop_filter= AVDISCARD_DEFAULT;
 static int error_resilience = FF_ER_CAREFUL;
 static int error_concealment = 3;
+static int decoder_reorder_pts= 0;
 
 /* current context */
 static int is_full_screen;
 static VideoState *cur_stream;
 static int64_t audio_callback_time;
 
+AVPacket flush_pkt;
+
 #define FF_ALLOC_EVENT   (SDL_USEREVENT)
 #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
@@ -254,7 +252,7 @@ static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
     AVPacketList *pkt1;
 
     /* duplicate the packet */
-    if (av_dup_packet(pkt) < 0)
+    if (pkt!=&flush_pkt && av_dup_packet(pkt) < 0)
         return -1;
 
     pkt1 = av_malloc(sizeof(AVPacketList));
@@ -409,7 +407,7 @@ void fill_border(VideoState *s, int x, int y, int w, int h, int color)
 
 #define YUVA_IN(y, u, v, a, s, pal)\
 {\
-    unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)s];\
+    unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
     a = (val >> 24) & 0xff;\
     y = (val >> 16) & 0xff;\
     u = (val >> 8) & 0xff;\
@@ -424,31 +422,36 @@ void fill_border(VideoState *s, int x, int y, int w, int h, int color)
 
 #define BPP 1
 
-static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
+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;
-
-    lum = dst->data[0] + rect->y * dst->linesize[0];
-    cb = dst->data[1] + (rect->y >> 1) * dst->linesize[1];
-    cr = dst->data[2] + (rect->y >> 1) * dst->linesize[2];
-
-    width2 = (rect->w + 1) >> 1;
-    skip2 = rect->x >> 1;
+    int dstx, dsty, dstw, dsth;
+
+    dstx = FFMIN(FFMAX(rect->x, 0), imgw);
+    dstw = FFMIN(FFMAX(rect->w, 0), imgw - dstx);
+    dsty = FFMIN(FFMAX(rect->y, 0), imgh);
+    dsth = FFMIN(FFMAX(rect->h, 0), imgh - dsty);
+    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;
+    skip2 = dstx >> 1;
     wrap = dst->linesize[0];
     wrap3 = rect->linesize;
     p = rect->bitmap;
     pal = rect->rgba_palette;  /* Now in YCrCb! */
 
-    if (rect->y & 1) {
-        lum += rect->x;
+    if (dsty & 1) {
+        lum += dstx;
         cb += skip2;
         cr += skip2;
 
-        if (rect->x & 1) {
+        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);
@@ -458,7 +461,7 @@ static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
             lum++;
             p += BPP;
         }
-        for(w = rect->w - (rect->x & 1); w >= 2; w -= 2) {
+        for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
             YUVA_IN(y, u, v, a, p, pal);
             u1 = u;
             v1 = v;
@@ -483,17 +486,17 @@ static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
             cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
             cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
         }
-        p += wrap3 + (wrap3 - rect->w * BPP);
-        lum += wrap + (wrap - rect->w - rect->x);
+        p += wrap3 + (wrap3 - dstw * BPP);
+        lum += wrap + (wrap - dstw - dstx);
         cb += dst->linesize[1] - width2 - skip2;
         cr += dst->linesize[2] - width2 - skip2;
     }
-    for(h = rect->h - (rect->y & 1); h >= 2; h -= 2) {
-        lum += rect->x;
+    for(h = dsth - (dsty & 1); h >= 2; h -= 2) {
+        lum += dstx;
         cb += skip2;
         cr += skip2;
 
-        if (rect->x & 1) {
+        if (dstx & 1) {
             YUVA_IN(y, u, v, a, p, pal);
             u1 = u;
             v1 = v;
@@ -513,7 +516,7 @@ static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
             p += -wrap3 + BPP;
             lum += -wrap + 1;
         }
-        for(w = rect->w - (rect->x & 1); w >= 2; w -= 2) {
+        for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
             YUVA_IN(y, u, v, a, p, pal);
             u1 = u;
             v1 = v;
@@ -568,18 +571,18 @@ static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
             p += -wrap3 + BPP;
             lum += -wrap + 1;
         }
-        p += wrap3 + (wrap3 - rect->w * BPP);
-        lum += wrap + (wrap - rect->w - rect->x);
+        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 += rect->x;
+        lum += dstx;
         cb += skip2;
         cr += skip2;
 
-        if (rect->x & 1) {
+        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);
@@ -589,7 +592,7 @@ static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
             lum++;
             p += BPP;
         }
-        for(w = rect->w - (rect->x & 1); w >= 2; w -= 2) {
+        for(w = dstw - (dstx & 1); w >= 2; w -= 2) {
             YUVA_IN(y, u, v, a, p, pal);
             u1 = u;
             v1 = v;
@@ -707,7 +710,8 @@ static void video_image_display(VideoState *is)
                     pict.linesize[2] = vp->bmp->pitches[1];
 
                     for (i = 0; i < sp->sub.num_rects; i++)
-                        blend_subrect(&pict, &sp->sub.rects[i]);
+                        blend_subrect(&pict, &sp->sub.rects[i],
+                                      vp->bmp->w, vp->bmp->h);
 
                     SDL_UnlockYUVOverlay (vp->bmp);
                 }
@@ -731,7 +735,7 @@ static void video_image_display(VideoState *is)
             is->no_background = 0;
         }
         rect.x = is->xleft + x;
-        rect.y = is->xleft + y;
+        rect.y = is->ytop  + y;
         rect.w = width;
         rect.h = height;
         SDL_DisplayYUVOverlay(vp->bmp, &rect);
@@ -777,7 +781,23 @@ static void video_audio_display(VideoState *s)
         delay -= s->width / 2;
         if (delay < s->width)
             delay = s->width;
-        i_start = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
+
+        i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
+
+        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;
@@ -825,9 +845,49 @@ static void video_audio_display(VideoState *s)
     SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
 }
 
+static int video_open(VideoState *is){
+    int flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
+    int w,h;
+
+    if(is_full_screen) flags |= SDL_FULLSCREEN;
+    else               flags |= SDL_RESIZABLE;
+
+    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 if (is->video_st && is->video_st->codec->width){
+        w = is->video_st->codec->width;
+        h = is->video_st->codec->height;
+    } else {
+        w = 640;
+        h = 480;
+    }
+#ifndef __APPLE__
+    screen = SDL_SetVideoMode(w, h, 0, flags);
+#else
+    /* setting bits_per_pixel = 0 or 32 causes blank video on OS X */
+    screen = SDL_SetVideoMode(w, h, 24, flags);
+#endif
+    if (!screen) {
+        fprintf(stderr, "SDL: could not set video mode - exiting\n");
+        return -1;
+    }
+    SDL_WM_SetCaption("FFplay", "FFplay");
+
+    is->width = screen->w;
+    is->height = screen->h;
+
+    return 0;
+}
+
 /* display the current picture, if any */
 static void video_display(VideoState *is)
 {
+    if(!screen)
+        video_open(cur_stream);
     if (is->audio_st && is->show_audio)
         video_audio_display(is);
     else if (is->video_st)
@@ -913,6 +973,8 @@ static void stream_seek(VideoState *is, int64_t pos, int rel)
     if (!is->seek_req) {
         is->seek_pos = pos;
         is->seek_flags = rel < 0 ? AVSEEK_FLAG_BACKWARD : 0;
+        if (seek_by_bytes)
+            is->seek_flags |= AVSEEK_FLAG_BYTE;
         is->seek_req = 1;
     }
 }
@@ -921,8 +983,9 @@ static void stream_seek(VideoState *is, int64_t pos, int rel)
 static void stream_pause(VideoState *is)
 {
     is->paused = !is->paused;
-    if (is->paused) {
+    if (!is->paused) {
         is->video_current_pts = get_video_clock(is);
+        is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
     }
 }
 
@@ -949,7 +1012,7 @@ static void video_refresh_timer(void *opaque)
 
             /* compute nominal delay */
             delay = vp->pts - is->frame_last_pts;
-            if (delay <= 0 || delay >= 1.0) {
+            if (delay <= 0 || delay >= 2.0) {
                 /* if incorrect delay, use previous one */
                 delay = is->frame_last_delay;
             }
@@ -1110,7 +1173,7 @@ static void alloc_picture(void *opaque)
     case PIX_FMT_YUV420P:
     case PIX_FMT_YUV422P:
     case PIX_FMT_YUV444P:
-    case PIX_FMT_YUV422:
+    case PIX_FMT_YUYV422:
     case PIX_FMT_YUV410P:
     case PIX_FMT_YUV411P:
         is_yuv = 1;
@@ -1142,6 +1205,7 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
     VideoPicture *vp;
     int dst_pix_fmt;
     AVPicture pict;
+    static struct SwsContext *img_convert_ctx;
 
     /* wait until we have space to put a new picture */
     SDL_LockMutex(is->pictq_mutex);
@@ -1194,9 +1258,17 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
         pict.linesize[0] = vp->bmp->pitches[0];
         pict.linesize[1] = vp->bmp->pitches[2];
         pict.linesize[2] = vp->bmp->pitches[1];
-        img_convert(&pict, dst_pix_fmt,
-                    (AVPicture *)src_frame, is->video_st->codec->pix_fmt,
-                    is->video_st->codec->width, is->video_st->codec->height);
+        img_convert_ctx = sws_getCachedContext(img_convert_ctx,
+            is->video_st->codec->width, is->video_st->codec->height,
+            is->video_st->codec->pix_fmt,
+            is->video_st->codec->width, is->video_st->codec->height,
+            dst_pix_fmt, sws_flags, NULL, NULL, NULL);
+        if (img_convert_ctx == NULL) {
+            fprintf(stderr, "Cannot initialize the conversion context\n");
+            exit(1);
+        }
+        sws_scale(img_convert_ctx, src_frame->data, src_frame->linesize,
+                  0, is->video_st->codec->height, pict.data, pict.linesize);
         /* update the bitmap content */
         SDL_UnlockYUVOverlay(vp->bmp);
 
@@ -1251,6 +1323,21 @@ static int output_picture2(VideoState *is, AVFrame *src_frame, double pts1)
     return queue_picture(is, src_frame, pts);
 }
 
+static uint64_t global_video_pkt_pts= AV_NOPTS_VALUE;
+
+static int my_get_buffer(struct AVCodecContext *c, AVFrame *pic){
+    int ret= avcodec_default_get_buffer(c, pic);
+    uint64_t *pts= av_malloc(sizeof(uint64_t));
+    *pts= global_video_pkt_pts;
+    pic->opaque= pts;
+    return ret;
+}
+
+static void my_release_buffer(struct AVCodecContext *c, AVFrame *pic){
+    if(pic) av_freep(&pic->opaque);
+    avcodec_default_release_buffer(c, pic);
+}
+
 static int video_thread(void *arg)
 {
     VideoState *is = arg;
@@ -1265,23 +1352,34 @@ static int video_thread(void *arg)
         }
         if (packet_queue_get(&is->videoq, pkt, 1) < 0)
             break;
+
+        if(pkt->data == flush_pkt.data){
+            avcodec_flush_buffers(is->video_st->codec);
+            continue;
+        }
+
         /* NOTE: ipts is the PTS of the _first_ picture beginning in
            this packet, if any */
-        pts = 0;
-        if (pkt->dts != AV_NOPTS_VALUE)
-            pts = av_q2d(is->video_st->time_base)*pkt->dts;
-
-            SDL_LockMutex(is->video_decoder_mutex);
-            len1 = avcodec_decode_video(is->video_st->codec,
-                                        frame, &got_picture,
-                                        pkt->data, pkt->size);
-            SDL_UnlockMutex(is->video_decoder_mutex);
+        global_video_pkt_pts= pkt->pts;
+        len1 = avcodec_decode_video(is->video_st->codec,
+                                    frame, &got_picture,
+                                    pkt->data, pkt->size);
+
+        if(   (decoder_reorder_pts || pkt->dts == AV_NOPTS_VALUE)
+           && frame->opaque && *(uint64_t*)frame->opaque != AV_NOPTS_VALUE)
+            pts= *(uint64_t*)frame->opaque;
+        else if(pkt->dts != AV_NOPTS_VALUE)
+            pts= pkt->dts;
+        else
+            pts= 0;
+        pts *= av_q2d(is->video_st->time_base);
+
 //            if (len1 < 0)
 //                break;
-            if (got_picture) {
-                if (output_picture2(is, frame, pts) < 0)
-                    goto the_end;
-            }
+        if (got_picture) {
+            if (output_picture2(is, frame, pts) < 0)
+                goto the_end;
+        }
         av_free_packet(pkt);
         if (step)
             if (cur_stream)
@@ -1309,6 +1407,10 @@ static int subtitle_thread(void *arg)
         if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
             break;
 
+        if(pkt->data == flush_pkt.data){
+            avcodec_flush_buffers(is->subtitle_st->codec);
+            continue;
+        }
         SDL_LockMutex(is->subpq_mutex);
         while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
                !is->subtitleq.abort_request) {
@@ -1327,11 +1429,9 @@ static int subtitle_thread(void *arg)
         if (pkt->pts != AV_NOPTS_VALUE)
             pts = av_q2d(is->subtitle_st->time_base)*pkt->pts;
 
-        SDL_LockMutex(is->subtitle_decoder_mutex);
         len1 = avcodec_decode_subtitle(is->subtitle_st->codec,
                                     &sp->sub, &got_subtitle,
                                     pkt->data, pkt->size);
-        SDL_UnlockMutex(is->subtitle_decoder_mutex);
 //            if (len1 < 0)
 //                break;
         if (got_subtitle && sp->sub.format == 0) {
@@ -1464,7 +1564,7 @@ static int synchronize_audio(VideoState *is, short *samples,
 }
 
 /* decode one audio frame and returns its uncompressed size */
-static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_ptr)
+static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size, double *pts_ptr)
 {
     AVPacket *pkt = &is->audio_pkt;
     int n, len1, data_size;
@@ -1473,11 +1573,10 @@ static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_pt
     for(;;) {
         /* NOTE: the audio packet can contain several frames */
         while (is->audio_pkt_size > 0) {
-            SDL_LockMutex(is->audio_decoder_mutex);
-            len1 = avcodec_decode_audio(is->audio_st->codec,
+            data_size = buf_size;
+            len1 = avcodec_decode_audio2(is->audio_st->codec,
                                         (int16_t *)audio_buf, &data_size,
                                         is->audio_pkt_data, is->audio_pkt_size);
-            SDL_UnlockMutex(is->audio_decoder_mutex);
             if (len1 < 0) {
                 /* if error, we skip the frame */
                 is->audio_pkt_size = 0;
@@ -1517,6 +1616,11 @@ static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_pt
         /* read next packet */
         if (packet_queue_get(&is->audioq, pkt, 1) < 0)
             return -1;
+        if(pkt->data == flush_pkt.data){
+            avcodec_flush_buffers(is->audio_st->codec);
+            continue;
+        }
+
         is->audio_pkt_data = pkt->data;
         is->audio_pkt_size = pkt->size;
 
@@ -1531,7 +1635,7 @@ static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_pt
    cannot have a precise information */
 static int audio_write_get_buf_size(VideoState *is)
 {
-    return is->audio_hw_buf_size - is->audio_buf_index;
+    return is->audio_buf_size - is->audio_buf_index;
 }
 
 
@@ -1546,7 +1650,7 @@ void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
 
     while (len > 0) {
         if (is->audio_buf_index >= is->audio_buf_size) {
-           audio_size = audio_decode_frame(is, is->audio_buf, &pts);
+           audio_size = audio_decode_frame(is, is->audio_buf, sizeof(is->audio_buf), &pts);
            if (audio_size < 0) {
                 /* if error, just output silence */
                is->audio_buf_size = 1024;
@@ -1570,7 +1674,6 @@ void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
     }
 }
 
-
 /* open a given stream. Return 0 if OK */
 static int stream_component_open(VideoState *is, int stream_index)
 {
@@ -1605,8 +1708,6 @@ static int stream_component_open(VideoState *is, int stream_index)
     codec = avcodec_find_decoder(enc->codec_id);
     enc->debug_mv = debug_mv;
     enc->debug = debug;
-    if(debug)
-        av_log_set_level(AV_LOG_DEBUG);
     enc->workaround_bugs = workaround_bugs;
     enc->lowres = lowres;
     if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
@@ -1620,10 +1721,8 @@ static int stream_component_open(VideoState *is, int stream_index)
     if (!codec ||
         avcodec_open(enc, codec) < 0)
         return -1;
-#if defined(HAVE_THREADS)
     if(thread_count>1)
         avcodec_thread_init(enc, thread_count);
-#endif
     enc->thread_count= thread_count;
     switch(enc->codec_type) {
     case CODEC_TYPE_AUDIO:
@@ -1653,6 +1752,9 @@ static int stream_component_open(VideoState *is, int stream_index)
 
         packet_queue_init(&is->videoq);
         is->video_tid = SDL_CreateThread(video_thread, is);
+
+        enc->    get_buffer=     my_get_buffer;
+        enc->release_buffer= my_release_buffer;
         break;
     case CODEC_TYPE_SUBTITLE:
         is->subtitle_stream = stream_index;
@@ -1735,7 +1837,7 @@ static void stream_component_close(VideoState *is, int stream_index)
     }
 }
 
-void dump_stream_info(AVFormatContext *s)
+static void dump_stream_info(const AVFormatContext *s)
 {
     if (s->track != 0)
         fprintf(stderr, "Track: %d\n", s->track);
@@ -1743,6 +1845,10 @@ void dump_stream_info(AVFormatContext *s)
         fprintf(stderr, "Title: %s\n", s->title);
     if (s->author[0] != '\0')
         fprintf(stderr, "Author: %s\n", s->author);
+    if (s->copyright[0] != '\0')
+        fprintf(stderr, "Copyright: %s\n", s->copyright);
+    if (s->comment[0] != '\0')
+        fprintf(stderr, "Comment: %s\n", s->comment);
     if (s->album[0] != '\0')
         fprintf(stderr, "Album: %s\n", s->album);
     if (s->year != 0)
@@ -1765,7 +1871,7 @@ static int decode_thread(void *arg)
 {
     VideoState *is = arg;
     AVFormatContext *ic;
-    int err, i, ret, video_index, audio_index, use_play;
+    int err, i, ret, video_index, audio_index;
     AVPacket pkt1, *pkt = &pkt1;
     AVFormatParameters params, *ap = &params;
 
@@ -1779,9 +1885,11 @@ static int decode_thread(void *arg)
     url_set_interrupt_cb(decode_interrupt_cb);
 
     memset(ap, 0, sizeof(*ap));
-    ap->image_format = image_format;
-    ap->initial_pause = 1; /* we force a pause when starting an RTSP
-                              stream */
+
+    ap->width = frame_width;
+    ap->height= frame_height;
+    ap->time_base= (AVRational){1, 25};
+    ap->pix_fmt = frame_pix_fmt;
 
     err = av_open_input_file(&ic, is->filename, is->iformat, 0, ap);
     if (err < 0) {
@@ -1790,24 +1898,17 @@ static int decode_thread(void *arg)
         goto fail;
     }
     is->ic = ic;
-#ifdef CONFIG_NETWORK
-    use_play = (ic->iformat == &rtsp_demux);
-#else
-    use_play = 0;
-#endif
 
     if(genpts)
         ic->flags |= AVFMT_FLAG_GENPTS;
 
-    if (!use_play) {
-        err = av_find_stream_info(ic);
-        if (err < 0) {
-            fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
-            ret = -1;
-            goto fail;
-        }
-        ic->pb.eof_reached= 0; //FIXME hack, ffplay maybe shouldnt use url_feof() to test for the end
+    err = av_find_stream_info(ic);
+    if (err < 0) {
+        fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
+        ret = -1;
+        goto fail;
     }
+    ic->pb.eof_reached= 0; //FIXME hack, ffplay maybe should not use url_feof() to test for the end
 
     /* if seeking requested, we execute it */
     if (start_time != AV_NOPTS_VALUE) {
@@ -1824,27 +1925,15 @@ static int decode_thread(void *arg)
         }
     }
 
-    /* now we can begin to play (RTSP stream only) */
-    av_read_play(ic);
-
-    if (use_play) {
-        err = av_find_stream_info(ic);
-        if (err < 0) {
-            fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
-            ret = -1;
-            goto fail;
-        }
-    }
-
     for(i = 0; i < ic->nb_streams; i++) {
         AVCodecContext *enc = ic->streams[i]->codec;
         switch(enc->codec_type) {
         case CODEC_TYPE_AUDIO:
-            if (audio_index < 0 && !audio_disable)
+            if ((audio_index < 0 || wanted_audio_stream-- > 0) && !audio_disable)
                 audio_index = i;
             break;
         case CODEC_TYPE_VIDEO:
-            if (video_index < 0 && !video_disable)
+            if ((video_index < 0 || wanted_video_stream-- > 0) && !video_disable)
                 video_index = i;
             break;
         default:
@@ -1877,7 +1966,6 @@ static int decode_thread(void *arg)
     for(;;) {
         if (is->abort_request)
             break;
-#ifdef CONFIG_NETWORK
         if (is->paused != is->last_paused) {
             is->last_paused = is->paused;
             if (is->paused)
@@ -1885,7 +1973,8 @@ static int decode_thread(void *arg)
             else
                 av_read_play(ic);
         }
-        if (is->paused && ic->iformat == &rtsp_demux) {
+#ifdef CONFIG_RTSP_DEMUXER
+        if (is->paused && !strcmp(ic->iformat->name, "rtsp")) {
             /* wait 10 ms to avoid trying to get another packet */
             /* XXX: horrible */
             SDL_Delay(10);
@@ -1893,28 +1982,34 @@ static int decode_thread(void *arg)
         }
 #endif
         if (is->seek_req) {
-            /* XXX: must lock decoder threads */
-            SDL_LockMutex(is->video_decoder_mutex);
-            SDL_LockMutex(is->audio_decoder_mutex);
-            SDL_LockMutex(is->subtitle_decoder_mutex);
-            ret = av_seek_frame(is->ic, -1, is->seek_pos, is->seek_flags);
+            int stream_index= -1;
+            int64_t seek_target= is->seek_pos;
+
+            if     (is->   video_stream >= 0) stream_index= is->   video_stream;
+            else if(is->   audio_stream >= 0) stream_index= is->   audio_stream;
+            else if(is->subtitle_stream >= 0) stream_index= is->subtitle_stream;
+
+            if(stream_index>=0){
+                seek_target= av_rescale_q(seek_target, AV_TIME_BASE_Q, ic->streams[stream_index]->time_base);
+            }
+
+            ret = av_seek_frame(is->ic, stream_index, seek_target, is->seek_flags);
             if (ret < 0) {
                 fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
             }else{
                 if (is->audio_stream >= 0) {
                     packet_queue_flush(&is->audioq);
+                    packet_queue_put(&is->audioq, &flush_pkt);
                 }
                 if (is->subtitle_stream >= 0) {
                     packet_queue_flush(&is->subtitleq);
+                    packet_queue_put(&is->subtitleq, &flush_pkt);
                 }
                 if (is->video_stream >= 0) {
                     packet_queue_flush(&is->videoq);
-                    avcodec_flush_buffers(ic->streams[video_index]->codec);
+                    packet_queue_put(&is->videoq, &flush_pkt);
                 }
             }
-            SDL_UnlockMutex(is->subtitle_decoder_mutex);
-            SDL_UnlockMutex(is->audio_decoder_mutex);
-            SDL_UnlockMutex(is->video_decoder_mutex);
             is->seek_req = 0;
         }
 
@@ -1985,12 +2080,8 @@ static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
     is = av_mallocz(sizeof(VideoState));
     if (!is)
         return NULL;
-    pstrcpy(is->filename, sizeof(is->filename), filename);
+    av_strlcpy(is->filename, filename, sizeof(is->filename));
     is->iformat = iformat;
-    if (screen) {
-        is->width = screen->w;
-        is->height = screen->h;
-    }
     is->ytop = 0;
     is->xleft = 0;
 
@@ -2001,10 +2092,6 @@ static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
     is->subpq_mutex = SDL_CreateMutex();
     is->subpq_cond = SDL_CreateCond();
 
-    is->subtitle_decoder_mutex = SDL_CreateMutex();
-    is->audio_decoder_mutex = SDL_CreateMutex();
-    is->video_decoder_mutex = SDL_CreateMutex();
-
     /* add the refresh timer to draw the picture */
     schedule_refresh(is, 40);
 
@@ -2037,12 +2124,9 @@ static void stream_close(VideoState *is)
     SDL_DestroyCond(is->pictq_cond);
     SDL_DestroyMutex(is->subpq_mutex);
     SDL_DestroyCond(is->subpq_cond);
-    SDL_DestroyMutex(is->subtitle_decoder_mutex);
-    SDL_DestroyMutex(is->audio_decoder_mutex);
-    SDL_DestroyMutex(is->video_decoder_mutex);
 }
 
-void stream_cycle_channel(VideoState *is, int codec_type)
+static void stream_cycle_channel(VideoState *is, int codec_type)
 {
     AVFormatContext *ic = is->ic;
     int start_index, stream_index;
@@ -2092,49 +2176,34 @@ void stream_cycle_channel(VideoState *is, int codec_type)
 }
 
 
-void toggle_full_screen(void)
+static void toggle_full_screen(void)
 {
-    int w, h, flags;
     is_full_screen = !is_full_screen;
     if (!fs_screen_width) {
         /* use default SDL method */
-        SDL_WM_ToggleFullScreen(screen);
-    } else {
-        /* use the recorded resolution */
-        flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
-        if (is_full_screen) {
-            w = fs_screen_width;
-            h = fs_screen_height;
-            flags |= SDL_FULLSCREEN;
-        } else {
-            w = screen_width;
-            h = screen_height;
-            flags |= SDL_RESIZABLE;
-        }
-        screen = SDL_SetVideoMode(w, h, 0, flags);
-        cur_stream->width = w;
-        cur_stream->height = h;
+//        SDL_WM_ToggleFullScreen(screen);
     }
+    video_open(cur_stream);
 }
 
-void toggle_pause(void)
+static void toggle_pause(void)
 {
     if (cur_stream)
         stream_pause(cur_stream);
     step = 0;
 }
 
-void step_to_next_frame(void)
+static void step_to_next_frame(void)
 {
     if (cur_stream) {
+        /* if the stream is paused unpause it, then step */
         if (cur_stream->paused)
-            cur_stream->paused=0;
-        cur_stream->video_current_pts = get_video_clock(cur_stream);
+            stream_pause(cur_stream);
     }
     step = 1;
 }
 
-void do_exit(void)
+static void do_exit(void)
 {
     if (cur_stream) {
         stream_close(cur_stream);
@@ -2146,7 +2215,7 @@ void do_exit(void)
     exit(0);
 }
 
-void toggle_audio_display(void)
+static void toggle_audio_display(void)
 {
     if (cur_stream) {
         cur_stream->show_audio = !cur_stream->show_audio;
@@ -2154,7 +2223,7 @@ void toggle_audio_display(void)
 }
 
 /* handle an event sent by the GUI */
-void event_loop(void)
+static void event_loop(void)
 {
     SDL_Event event;
     double incr, pos, frac;
@@ -2206,9 +2275,19 @@ void event_loop(void)
                 incr = -60.0;
             do_seek:
                 if (cur_stream) {
-                    pos = get_master_clock(cur_stream);
-                    pos += incr;
-                    stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), incr);
+                    if (seek_by_bytes) {
+                        pos = url_ftell(&cur_stream->ic->pb);
+                        if (cur_stream->ic->bit_rate)
+                            incr *= cur_stream->ic->bit_rate / 60.0;
+                        else
+                            incr *= 180000.0;
+                        pos += incr;
+                        stream_seek(cur_stream, pos, incr);
+                    } else {
+                        pos = get_master_clock(cur_stream);
+                        pos += incr;
+                        stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), incr);
+                    }
                 }
                 break;
             default:
@@ -2237,8 +2316,8 @@ void event_loop(void)
             if (cur_stream) {
                 screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
                                           SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
-                cur_stream->width = event.resize.w;
-                cur_stream->height = event.resize.h;
+                screen_width = cur_stream->width = event.resize.w;
+                screen_height= cur_stream->height= event.resize.h;
             }
             break;
         case SDL_QUIT:
@@ -2246,6 +2325,7 @@ void event_loop(void)
             do_exit();
             break;
         case FF_ALLOC_EVENT:
+            video_open(event.user.data1);
             alloc_picture(event.user.data1);
             break;
         case FF_REFRESH_EVENT:
@@ -2257,14 +2337,34 @@ void event_loop(void)
     }
 }
 
-void opt_width(const char *arg)
+static void opt_frame_size(const char *arg)
+{
+    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
+        fprintf(stderr, "Incorrect frame size\n");
+        exit(1);
+    }
+    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
+        fprintf(stderr, "Frame size must be a multiple of 2\n");
+        exit(1);
+    }
+}
+
+static void opt_width(const char *arg)
 {
     screen_width = atoi(arg);
+    if(screen_width<=0){
+        fprintf(stderr, "invalid width\n");
+        exit(1);
+    }
 }
 
-void opt_height(const char *arg)
+static void opt_height(const char *arg)
 {
     screen_height = atoi(arg);
+    if(screen_height<=0){
+        fprintf(stderr, "invalid height\n");
+        exit(1);
+    }
 }
 
 static void opt_format(const char *arg)
@@ -2276,30 +2376,20 @@ static void opt_format(const char *arg)
     }
 }
 
-static void opt_image_format(const char *arg)
+static void opt_frame_pix_fmt(const char *arg)
 {
-    AVImageFormat *f;
-
-    for(f = first_image_format; f != NULL; f = f->next) {
-        if (!strcmp(arg, f->name))
-            break;
-    }
-    if (!f) {
-        fprintf(stderr, "Unknown image format: '%s'\n", arg);
-        exit(1);
-    }
-    image_format = f;
+    frame_pix_fmt = avcodec_get_pix_fmt(arg);
 }
 
-#ifdef CONFIG_NETWORK
-void opt_rtp_tcp(void)
+#ifdef CONFIG_RTSP_DEMUXER
+static void opt_rtp_tcp(void)
 {
     /* only tcp protocol */
     rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_TCP);
 }
 #endif
 
-void opt_sync(const char *arg)
+static void opt_sync(const char *arg)
 {
     if (!strcmp(arg, "audio"))
         av_sync_type = AV_SYNC_AUDIO_MASTER;
@@ -2307,17 +2397,24 @@ void opt_sync(const char *arg)
         av_sync_type = AV_SYNC_VIDEO_MASTER;
     else if (!strcmp(arg, "ext"))
         av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
-    else
+    else {
         show_help();
+        exit(1);
+    }
 }
 
-void opt_seek(const char *arg)
+static void opt_seek(const char *arg)
 {
     start_time = parse_date(arg, 1);
+    if (start_time == INT64_MIN) {
+        fprintf(stderr, "Invalid duration specification: %s\n", arg);
+        exit(1);
+    }
 }
 
 static void opt_debug(const char *arg)
 {
+    av_log_level = 99;
     debug = atoi(arg);
 }
 
@@ -2334,23 +2431,34 @@ static void opt_thread_count(const char *arg)
 #endif
 }
 
+static void opt_show_help(void)
+{
+    show_help();
+    exit(0);
+}
+
 const OptionDef options[] = {
-    { "h", 0, {(void*)show_help}, "show help" },
+    { "h", 0, {(void*)opt_show_help}, "show help" },
     { "x", HAS_ARG, {(void*)opt_width}, "force displayed width", "width" },
     { "y", HAS_ARG, {(void*)opt_height}, "force displayed height", "height" },
+    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
     { "fs", OPT_BOOL, {(void*)&is_full_screen}, "force full screen" },
     { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
     { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
+    { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_audio_stream}, "", "" },
+    { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&wanted_video_stream}, "", "" },
     { "ss", HAS_ARG, {(void*)&opt_seek}, "seek to a given position in seconds", "pos" },
+    { "bytes", OPT_BOOL, {(void*)&seek_by_bytes}, "seek by bytes" },
     { "nodisp", OPT_BOOL, {(void*)&display_disable}, "disable graphical display" },
     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
-    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
+    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
     { "stats", OPT_BOOL | OPT_EXPERT, {(void*)&show_status}, "show status", "" },
     { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
     { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&workaround_bugs}, "workaround bugs", "" },
     { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
     { "fast", OPT_BOOL | OPT_EXPERT, {(void*)&fast}, "non spec compliant optimizations", "" },
     { "genpts", OPT_BOOL | OPT_EXPERT, {(void*)&genpts}, "generate pts", "" },
+    { "drp", OPT_BOOL |OPT_EXPERT, {(void*)&decoder_reorder_pts}, "let decoder reorder pts", ""},
     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&lowres}, "", "" },
     { "skiploop", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_loop_filter}, "", "" },
     { "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&skip_frame}, "", "" },
@@ -2358,7 +2466,7 @@ const OptionDef options[] = {
     { "idct", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&idct}, "set idct algo",  "algo" },
     { "er", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_resilience}, "set error detection threshold (0-4)",  "threshold" },
     { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&error_concealment}, "set error concealment options",  "bit_mask" },
-#ifdef CONFIG_NETWORK
+#ifdef CONFIG_RTSP_DEMUXER
     { "rtp_tcp", OPT_EXPERT, {(void*)&opt_rtp_tcp}, "force RTP/TCP protocol usage", "" },
 #endif
     { "sync", HAS_ARG | OPT_EXPERT, {(void*)opt_sync}, "set audio-video sync. type (type=audio/video/ext)", "type" },
@@ -2368,7 +2476,7 @@ const OptionDef options[] = {
 
 void show_help(void)
 {
-    printf("ffplay version " FFMPEG_VERSION ", Copyright (c) 2003 Fabrice Bellard\n"
+    printf("ffplay version " FFMPEG_VERSION ", Copyright (c) 2003-2007 Fabrice Bellard, et al.\n"
            "usage: ffplay [options] input_file\n"
            "Simple media player\n");
     printf("\n");
@@ -2388,43 +2496,36 @@ void show_help(void)
            "down/up             seek backward/forward 1 minute\n"
            "mouse click         seek to percentage in file corresponding to fraction of width\n"
            );
-    exit(1);
 }
 
-void parse_arg_file(const char *filename)
+void opt_input_file(const char *filename)
 {
     if (!strcmp(filename, "-"))
-                    filename = "pipe:";
+        filename = "pipe:";
     input_filename = filename;
 }
 
 /* Called from the main */
 int main(int argc, char **argv)
 {
-    int flags, w, h;
+    int flags;
 
     /* register all codecs, demux and protocols */
     av_register_all();
 
-    #ifdef CONFIG_OS2
-      MorphToPM(); // Morph the VIO application to a PM one to be able to use Win* functions
-
-      // Make stdout and stderr unbuffered
-      setbuf( stdout, NULL );
-      setbuf( stderr, NULL );
-    #endif
+    parse_options(argc, argv, options, opt_input_file);
 
-    parse_options(argc, argv, options);
-
-    if (!input_filename)
+    if (!input_filename) {
         show_help();
+        exit(1);
+    }
 
     if (display_disable) {
         video_disable = 1;
     }
     flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
-#if !defined(CONFIG_WIN32) && !defined(CONFIG_DARWIN)
-    flags |= SDL_INIT_EVENTTHREAD; /* Not supported on win32 or darwin */
+#if !defined(__MINGW32__) && !defined(__APPLE__)
+    flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
 #endif
     if (SDL_Init (flags)) {
         fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
@@ -2437,27 +2538,6 @@ int main(int argc, char **argv)
         fs_screen_width = vi->current_w;
         fs_screen_height = vi->current_h;
 #endif
-        flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
-        if (is_full_screen && fs_screen_width) {
-            w = fs_screen_width;
-            h = fs_screen_height;
-            flags |= SDL_FULLSCREEN;
-        } else {
-            w = screen_width;
-            h = screen_height;
-            flags |= SDL_RESIZABLE;
-        }
-#ifndef CONFIG_DARWIN
-        screen = SDL_SetVideoMode(w, h, 0, flags);
-#else
-        /* setting bits_per_pixel = 0 or 32 causes blank video on OS X */
-        screen = SDL_SetVideoMode(w, h, 24, flags);
-#endif
-        if (!screen) {
-            fprintf(stderr, "SDL: could not set video mode - exiting\n");
-            exit(1);
-        }
-        SDL_WM_SetCaption("FFplay", "FFplay");
     }
 
     SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
@@ -2465,6 +2545,9 @@ int main(int argc, char **argv)
     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
 
+    av_init_packet(&flush_pkt);
+    flush_pkt.data= "FLUSH";
+
     cur_stream = stream_open(input_filename, file_iformat);
 
     event_loop();