* 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 "avformat.h"
+#include "swscale.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
/* 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 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;
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;
/* 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_height = 480;
static int audio_disable;
static int video_disable;
+static int seek_by_bytes;
static int display_disable;
static int show_status;
static int av_sync_type = AV_SYNC_AUDIO_MASTER;
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)
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));
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;
}
}
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);
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);
+ if (img_convert_ctx == NULL) {
+ img_convert_ctx = sws_getContext(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);
}
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);
// if (len1 < 0)
// break;
if (got_picture) {
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) {
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) {
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,
(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;
/* 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;
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;
}
}
-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);
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)
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 */
}
is->ic = ic;
#ifdef CONFIG_NETWORK
- use_play = (ic->iformat == &rtsp_demux);
+ use_play = (ic->iformat == &rtsp_demuxer);
#else
use_play = 0;
#endif
else
av_read_play(ic);
}
- if (is->paused && ic->iformat == &rtsp_demux) {
+ if (is->paused && ic->iformat == &rtsp_demuxer) {
/* wait 10 ms to avoid trying to get another packet */
/* XXX: horrible */
SDL_Delay(10);
}
#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);
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;
}
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);
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;
}
-void toggle_full_screen(void)
+static void toggle_full_screen(void)
{
int w, h, flags;
is_full_screen = !is_full_screen;
}
}
-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 (cur_stream->paused)
step = 1;
}
-void do_exit(void)
+static void do_exit(void)
{
if (cur_stream) {
stream_close(cur_stream);
exit(0);
}
-void toggle_audio_display(void)
+static void toggle_audio_display(void)
{
if (cur_stream) {
cur_stream->show_audio = !cur_stream->show_audio;
}
/* handle an event sent by the GUI */
-void event_loop(void)
+static void event_loop(void)
{
SDL_Event event;
double incr, pos, frac;
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:
}
}
-static void opt_image_format(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;
-}
-
#ifdef CONFIG_NETWORK
void opt_rtp_tcp(void)
{
static void opt_debug(const char *arg)
{
+ av_log_set_level(99);
debug = atoi(arg);
}
{ "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
{ "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
{ "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" },
{ "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", "" },
void show_help(void)
{
- printf("ffplay version " FFMPEG_VERSION ", Copyright (c) 2003 Fabrice Bellard\n"
+ printf("ffplay version " FFMPEG_VERSION ", Copyright (c) 2003-2006 Fabrice Bellard, et al.\n"
"usage: ffplay [options] input_file\n"
"Simple media player\n");
printf("\n");
video_disable = 1;
}
flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
-#if !defined(CONFIG_WIN32) && !defined(CONFIG_DARWIN)
+#if !defined(__MINGW32__) && !defined(CONFIG_DARWIN)
flags |= SDL_INIT_EVENTTHREAD; /* Not supported on win32 or darwin */
#endif
if (SDL_Init (flags)) {
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();