2003-01-28 01:02:07 +00:00
|
|
|
/*
|
|
|
|
GIF file parser for MPlayer
|
|
|
|
by Joey Parrish
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include "mp_msg.h"
|
|
|
|
#include "help_mp.h"
|
|
|
|
|
|
|
|
#include "stream.h"
|
|
|
|
#include "demuxer.h"
|
|
|
|
#include "stheader.h"
|
|
|
|
|
|
|
|
#include <gif_lib.h>
|
2007-01-13 11:44:36 +00:00
|
|
|
#include "libvo/fastmemcpy.h"
|
2007-01-13 11:05:32 +00:00
|
|
|
typedef struct {
|
|
|
|
int current_pts;
|
|
|
|
unsigned char *palette;
|
|
|
|
GifFileType *gif;
|
2007-01-13 11:37:18 +00:00
|
|
|
int w, h;
|
2007-01-13 12:19:42 +00:00
|
|
|
int useref;
|
|
|
|
char *refimg;
|
2007-01-13 11:05:32 +00:00
|
|
|
} gif_priv_t;
|
2003-01-28 01:02:07 +00:00
|
|
|
|
|
|
|
#define GIF_SIGNATURE (('G' << 16) | ('I' << 8) | 'F')
|
|
|
|
|
2003-02-19 16:55:14 +00:00
|
|
|
#ifndef HAVE_GIF_TVT_HACK
|
|
|
|
// not supported by certain versions of the library
|
2003-02-08 15:49:03 +00:00
|
|
|
int my_read_gif(GifFileType *gif, uint8_t *buf, int len) {
|
|
|
|
return stream_read(gif->UserData, buf, len);
|
|
|
|
}
|
2003-02-19 16:55:14 +00:00
|
|
|
#endif
|
2003-02-08 15:49:03 +00:00
|
|
|
|
2005-08-05 19:57:47 +00:00
|
|
|
static int gif_check_file(demuxer_t *demuxer)
|
2003-01-28 01:02:07 +00:00
|
|
|
{
|
|
|
|
if (stream_read_int24(demuxer->stream) == GIF_SIGNATURE)
|
2005-08-05 19:57:47 +00:00
|
|
|
return DEMUXER_TYPE_GIF;
|
2003-01-28 01:02:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-05 19:57:47 +00:00
|
|
|
static int demux_gif_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds)
|
2003-01-28 01:02:07 +00:00
|
|
|
{
|
2007-01-13 11:05:32 +00:00
|
|
|
gif_priv_t *priv = demuxer->priv;
|
|
|
|
GifFileType *gif = priv->gif;
|
2003-01-28 01:02:07 +00:00
|
|
|
GifRecordType type = UNDEFINED_RECORD_TYPE;
|
|
|
|
int len = 0;
|
|
|
|
demux_packet_t *dp = NULL;
|
|
|
|
ColorMapObject *effective_map = NULL;
|
|
|
|
char *buf = NULL;
|
2007-01-13 12:19:42 +00:00
|
|
|
int refmode = 0;
|
2003-01-28 01:02:07 +00:00
|
|
|
|
|
|
|
while (type != IMAGE_DESC_RECORD_TYPE) {
|
|
|
|
if (DGifGetRecordType(gif, &type) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
if (type == TERMINATE_RECORD_TYPE)
|
|
|
|
return 0; // eof
|
|
|
|
if (type == SCREEN_DESC_RECORD_TYPE) {
|
|
|
|
if (DGifGetScreenDesc(gif) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (type == EXTENSION_RECORD_TYPE) {
|
|
|
|
int code;
|
|
|
|
unsigned char *p = NULL;
|
|
|
|
if (DGifGetExtension(gif, &code, &p) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
if (code == 0xF9) {
|
|
|
|
int frametime = 0;
|
|
|
|
if (p[0] == 4) // is the length correct?
|
2007-01-13 12:19:42 +00:00
|
|
|
{
|
2007-01-13 06:00:34 +00:00
|
|
|
frametime = (p[3] << 8) | p[2]; // set the time, centiseconds
|
2007-01-13 12:19:42 +00:00
|
|
|
refmode = (p[1] >> 2) & 3;
|
|
|
|
}
|
2007-01-13 11:05:32 +00:00
|
|
|
priv->current_pts += frametime;
|
2003-01-28 01:02:07 +00:00
|
|
|
} else if ((code == 0xFE) && (verbose)) { // comment extension
|
|
|
|
// print iff verbose
|
|
|
|
printf("GIF comment: ");
|
|
|
|
while (p != NULL) {
|
|
|
|
int length = p[0];
|
|
|
|
char *comments = p + 1;
|
|
|
|
comments[length] = 0;
|
|
|
|
printf("%s", comments);
|
|
|
|
if (DGifGetExtensionNext(gif, &p) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
while (p != NULL) {
|
|
|
|
if (DGifGetExtensionNext(gif, &p) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DGifGetImageDesc(gif) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
|
|
|
|
len = gif->Image.Width * gif->Image.Height;
|
2007-01-13 11:37:18 +00:00
|
|
|
dp = new_demux_packet(priv->w * priv->h);
|
2007-01-13 12:05:18 +00:00
|
|
|
buf = calloc(gif->Image.Width, gif->Image.Height);
|
2007-01-13 12:19:42 +00:00
|
|
|
if (priv->useref)
|
|
|
|
memcpy(dp->buffer, priv->refimg, priv->w * priv->h);
|
|
|
|
else
|
|
|
|
memset(dp->buffer, gif->SBackGroundColor, priv->w * priv->h);
|
2003-01-28 01:02:07 +00:00
|
|
|
|
|
|
|
if (DGifGetLine(gif, buf, len) == GIF_ERROR) {
|
|
|
|
PrintGifError();
|
|
|
|
return 0; // oops
|
|
|
|
}
|
|
|
|
|
|
|
|
effective_map = gif->Image.ColorMap;
|
|
|
|
if (effective_map == NULL) effective_map = gif->SColorMap;
|
|
|
|
|
|
|
|
{
|
|
|
|
int y;
|
2007-01-13 11:37:59 +00:00
|
|
|
int cnt = FFMIN(effective_map->ColorCount, 256);
|
2007-01-13 11:40:05 +00:00
|
|
|
int l = FFMAX(FFMIN(gif->Image.Left, priv->w), 0);
|
|
|
|
int t = FFMAX(FFMIN(gif->Image.Top, priv->h), 0);
|
|
|
|
int w = FFMAX(FFMIN(gif->Image.Width, priv->w - l), 0);
|
|
|
|
int h = FFMAX(FFMIN(gif->Image.Height, priv->h - t), 0);
|
2007-01-13 11:44:36 +00:00
|
|
|
unsigned char *dest = dp->buffer + priv->w * t + l;
|
2003-01-28 01:02:07 +00:00
|
|
|
|
2007-01-13 06:02:31 +00:00
|
|
|
// copy the palette
|
2007-01-13 11:06:40 +00:00
|
|
|
for (y = 0; y < cnt; y++) {
|
2007-01-13 12:39:13 +00:00
|
|
|
priv->palette[(y * 4) + 0] = effective_map->Colors[y].Blue;
|
|
|
|
priv->palette[(y * 4) + 1] = effective_map->Colors[y].Green;
|
|
|
|
priv->palette[(y * 4) + 2] = effective_map->Colors[y].Red;
|
|
|
|
priv->palette[(y * 4) + 3] = 0;
|
2003-01-28 01:02:07 +00:00
|
|
|
}
|
|
|
|
|
2007-01-13 11:44:36 +00:00
|
|
|
memcpy_pic(dest, buf, w, h, priv->w, gif->Image.Width);
|
2003-01-28 01:02:07 +00:00
|
|
|
|
2007-01-13 12:39:13 +00:00
|
|
|
priv->useref = 1;
|
|
|
|
if (refmode == 1) memcpy(priv->refimg, dp->buffer, priv->w * priv->h);
|
2007-01-13 12:37:53 +00:00
|
|
|
if (refmode == 2 && priv->useref) {
|
|
|
|
dest = priv->refimg + priv->w * t + l;
|
|
|
|
memset(buf, gif->SBackGroundColor, len);
|
|
|
|
memcpy_pic(dest, buf, w, h, priv->w, gif->Image.Width);
|
|
|
|
}
|
2007-01-13 12:39:13 +00:00
|
|
|
if (!refmode) priv->useref = 0;
|
2007-01-13 12:37:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
free(buf);
|
2007-01-13 12:19:42 +00:00
|
|
|
|
2003-01-28 01:02:07 +00:00
|
|
|
demuxer->video->dpos++;
|
2007-01-13 11:05:32 +00:00
|
|
|
dp->pts = ((float)priv->current_pts) / 100;
|
2003-01-28 01:02:07 +00:00
|
|
|
dp->pos = stream_tell(demuxer->stream);
|
|
|
|
ds_add_packet(demuxer->video, dp);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-08-05 19:57:47 +00:00
|
|
|
static demuxer_t* demux_open_gif(demuxer_t* demuxer)
|
2003-01-28 01:02:07 +00:00
|
|
|
{
|
2007-01-13 11:05:32 +00:00
|
|
|
gif_priv_t *priv = calloc(1, sizeof(gif_priv_t));
|
2003-01-28 01:02:07 +00:00
|
|
|
sh_video_t *sh_video = NULL;
|
|
|
|
GifFileType *gif = NULL;
|
|
|
|
|
2007-01-13 11:05:32 +00:00
|
|
|
priv->current_pts = 0;
|
2003-01-28 01:02:07 +00:00
|
|
|
demuxer->seekable = 0; // FIXME
|
|
|
|
|
|
|
|
// go back to the beginning
|
2003-02-08 17:29:43 +00:00
|
|
|
stream_seek(demuxer->stream,demuxer->stream->start_pos);
|
2003-01-28 01:02:07 +00:00
|
|
|
|
2003-02-19 16:55:14 +00:00
|
|
|
#ifdef HAVE_GIF_TVT_HACK
|
|
|
|
// without the TVT functionality of libungif, a hard seek must be
|
|
|
|
// done to the beginning of the file. this is because libgif is
|
|
|
|
// unable to use mplayer's cache, and without this lseek libgif will
|
|
|
|
// not read from the beginning of the file and the command will fail.
|
|
|
|
// with this hack enabled, you will lose the ability to stream a GIF.
|
|
|
|
lseek(demuxer->stream->fd, 0, SEEK_SET);
|
|
|
|
gif = DGifOpenFileHandle(demuxer->stream->fd);
|
|
|
|
#else
|
2003-02-08 15:49:03 +00:00
|
|
|
gif = DGifOpen(demuxer->stream, my_read_gif);
|
2003-02-19 16:55:14 +00:00
|
|
|
#endif
|
2003-01-28 01:02:07 +00:00
|
|
|
if (!gif) {
|
|
|
|
PrintGifError();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// create a new video stream header
|
|
|
|
sh_video = new_sh_video(demuxer, 0);
|
|
|
|
|
|
|
|
// make sure the demuxer knows about the new video stream header
|
|
|
|
// (even though new_sh_video() ought to take care of it)
|
|
|
|
demuxer->video->sh = sh_video;
|
|
|
|
|
|
|
|
// make sure that the video demuxer stream header knows about its
|
|
|
|
// parent video demuxer stream (this is getting wacky), or else
|
|
|
|
// video_read_properties() will choke
|
|
|
|
sh_video->ds = demuxer->video;
|
|
|
|
|
2007-01-13 11:49:20 +00:00
|
|
|
sh_video->disp_w = (uint16_t)gif->SWidth;
|
|
|
|
sh_video->disp_h = (uint16_t)gif->SHeight;
|
2003-01-28 01:02:07 +00:00
|
|
|
|
|
|
|
sh_video->format = mmioFOURCC(8, 'R', 'G', 'B');
|
|
|
|
|
|
|
|
sh_video->fps = 5.0f;
|
|
|
|
sh_video->frametime = 1.0f / sh_video->fps;
|
|
|
|
|
|
|
|
sh_video->bih = malloc(sizeof(BITMAPINFOHEADER) + (256 * 4));
|
|
|
|
sh_video->bih->biCompression = sh_video->format;
|
|
|
|
sh_video->bih->biBitCount = 8;
|
|
|
|
sh_video->bih->biPlanes = 2;
|
2007-01-13 11:05:32 +00:00
|
|
|
priv->palette = (unsigned char *)(sh_video->bih + 1);
|
2007-01-13 11:37:18 +00:00
|
|
|
priv->w = sh_video->disp_w;
|
|
|
|
priv->h = sh_video->disp_h;
|
2007-01-13 12:19:42 +00:00
|
|
|
priv->refimg = malloc(priv->w * priv->h);
|
2003-01-28 01:02:07 +00:00
|
|
|
|
2007-01-13 11:05:32 +00:00
|
|
|
priv->gif = gif;
|
|
|
|
demuxer->priv = priv;
|
2003-01-28 01:02:07 +00:00
|
|
|
|
|
|
|
return demuxer;
|
|
|
|
}
|
|
|
|
|
2005-08-05 19:57:47 +00:00
|
|
|
static void demux_close_gif(demuxer_t* demuxer)
|
2003-01-28 01:02:07 +00:00
|
|
|
{
|
2007-01-13 11:05:32 +00:00
|
|
|
gif_priv_t *priv = demuxer->priv;
|
|
|
|
if (!priv) return;
|
|
|
|
if (priv->gif && DGifCloseFile(priv->gif) == GIF_ERROR)
|
2003-01-28 01:02:07 +00:00
|
|
|
PrintGifError();
|
2007-01-13 12:19:42 +00:00
|
|
|
free(priv->refimg);
|
2007-01-13 11:05:32 +00:00
|
|
|
free(priv);
|
2003-01-28 01:02:07 +00:00
|
|
|
}
|
2005-08-05 19:57:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
demuxer_desc_t demuxer_desc_gif = {
|
|
|
|
"GIF demuxer",
|
|
|
|
"gif",
|
|
|
|
"GIF",
|
|
|
|
"Joey Parrish",
|
|
|
|
"",
|
|
|
|
DEMUXER_TYPE_GIF,
|
|
|
|
0, // unsafe autodetect
|
|
|
|
gif_check_file,
|
|
|
|
demux_gif_fill_buffer,
|
|
|
|
demux_open_gif,
|
|
|
|
demux_close_gif,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|