Update to MPlayer SVN rev 35107.
[vaapi:mplayer.git] / libmpdemux / demux_mf.c
1 /*
2  * This file is part of MPlayer.
3  *
4  * MPlayer is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * MPlayer is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <unistd.h>
25
26 #include "config.h"
27 #include "mp_msg.h"
28 #include "help_mp.h"
29
30 #include "stream/stream.h"
31 #include "demuxer.h"
32 #include "stheader.h"
33 #include "mf.h"
34
35 static void demux_seek_mf(demuxer_t *demuxer,float rel_seek_secs,float audio_delay,int flags){
36   mf_t * mf = (mf_t *)demuxer->priv;
37   sh_video_t   * sh_video = demuxer->video->sh;
38   int newpos = (flags & SEEK_ABSOLUTE)?0:mf->curr_frame - 1;
39
40   if ( flags & SEEK_FACTOR ) newpos+=rel_seek_secs*(mf->nr_of_files - 1);
41    else newpos+=rel_seek_secs * sh_video->fps;
42   if ( newpos < 0 ) newpos=0;
43   if( newpos >= mf->nr_of_files) newpos=mf->nr_of_files - 1;
44   demuxer->filepos=mf->curr_frame=newpos;
45 }
46
47 // return value:
48 //     0 = EOF or no stream found
49 //     1 = successfully read a packet
50 static int demux_mf_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds){
51   mf_t         * mf;
52   struct stat    fs;
53   FILE         * f;
54
55   mf=(mf_t*)demuxer->priv;
56   if ( mf->curr_frame >= mf->nr_of_files ) return 0;
57
58   stat( mf->names[mf->curr_frame],&fs );
59 //  printf( "[demux_mf] frame: %d (%s,%d)\n",mf->curr_frame,mf->names[mf->curr_frame],fs.st_size );
60
61   if ( !( f=fopen( mf->names[mf->curr_frame],"rb" ) ) ) return 0;
62   {
63    sh_video_t     * sh_video = demuxer->video->sh;
64    demux_packet_t * dp = new_demux_packet( fs.st_size );
65    if ( !fread( dp->buffer,fs.st_size,1,f ) ) return 0;
66    dp->pts=mf->curr_frame / sh_video->fps;
67    dp->pos=mf->curr_frame;
68    dp->flags=1;
69    // append packet to DS stream:
70    ds_add_packet( demuxer->video,dp );
71   }
72   fclose( f );
73
74   demuxer->filepos=mf->curr_frame++;
75   return 1;
76 }
77
78 // force extension/type to have a fourcc
79
80 static const struct {
81   const char *type;
82   uint32_t format;
83 } type2format[] = {
84   { "bmp",  mmioFOURCC('b', 'm', 'p', ' ') },
85   { "dpx",  mmioFOURCC('d', 'p', 'x', ' ') },
86   { "j2c",  mmioFOURCC('M', 'J', '2', 'C') },
87   { "j2k",  mmioFOURCC('M', 'J', '2', 'C') },
88   { "jp2",  mmioFOURCC('M', 'J', '2', 'C') },
89   { "jpc",  mmioFOURCC('M', 'J', '2', 'C') },
90   { "jpeg", mmioFOURCC('I', 'J', 'P', 'G') },
91   { "jpg",  mmioFOURCC('I', 'J', 'P', 'G') },
92   { "jps",  mmioFOURCC('I', 'J', 'P', 'G') },
93   { "jls",  mmioFOURCC('I', 'J', 'P', 'G') },
94   { "thm",  mmioFOURCC('I', 'J', 'P', 'G') },
95   { "db",   mmioFOURCC('I', 'J', 'P', 'G') },
96   { "pcx",  mmioFOURCC('p', 'c', 'x', ' ') },
97   { "png",  mmioFOURCC('M', 'P', 'N', 'G') },
98   { "pns",  mmioFOURCC('M', 'P', 'N', 'G') },
99   { "ptx",  mmioFOURCC('p', 't', 'x', ' ') },
100   { "tga",  mmioFOURCC('M', 'T', 'G', 'A') },
101   { "tif",  mmioFOURCC('t', 'i', 'f', 'f') },
102   { "tiff",  mmioFOURCC('t', 'i', 'f', 'f') },
103   { "sgi",  mmioFOURCC('S', 'G', 'I', '1') },
104   { "sun",  mmioFOURCC('s', 'u', 'n', ' ') },
105   { "ras",  mmioFOURCC('s', 'u', 'n', ' ') },
106   { "ra",  mmioFOURCC('s', 'u', 'n', ' ') },
107   { "im1",  mmioFOURCC('s', 'u', 'n', ' ') },
108   { "im8",  mmioFOURCC('s', 'u', 'n', ' ') },
109   { "im24",  mmioFOURCC('s', 'u', 'n', ' ') },
110   { "sunras",  mmioFOURCC('s', 'u', 'n', ' ') },
111   { NULL,   0 }
112 };
113
114 static demuxer_t* demux_open_mf(demuxer_t* demuxer){
115   sh_video_t   *sh_video = NULL;
116   mf_t         *mf = NULL;
117   int i;
118
119   if(!demuxer->stream->url) return NULL;
120   if(strncmp(demuxer->stream->url, "mf://", 5)) return NULL;
121
122
123   mf=open_mf(demuxer->stream->url + 5);
124   if(!mf) return NULL;
125
126   if(!mf_type){
127     char* p=strrchr(mf->names[0],'.');
128     if(!p){
129       mp_msg(MSGT_DEMUX, MSGL_INFO, "[demux_mf] file type was not set! (try -mf type=xxx)\n" );
130       free( mf ); return NULL;
131     }
132     mf_type=strdup(p+1);
133     mp_msg(MSGT_DEMUX, MSGL_INFO, "[demux_mf] file type was not set! trying 'type=%s'...\n", mf_type);
134   }
135
136   demuxer->filepos=mf->curr_frame=0;
137
138   demuxer->movi_start = 0;
139   demuxer->movi_end = mf->nr_of_files - 1;
140
141   // create a new video stream header
142   sh_video = new_sh_video(demuxer, 0);
143   // make sure the demuxer knows about the new video stream header
144   // (even though new_sh_video() ought to take care of it)
145   demuxer->video->sh = sh_video;
146
147   // make sure that the video demuxer stream header knows about its
148   // parent video demuxer stream (this is getting wacky), or else
149   // video_read_properties() will choke
150   sh_video->ds = demuxer->video;
151
152   for (i = 0; type2format[i].type; i++)
153     if (strcasecmp(mf_type, type2format[i].type) == 0)
154       break;
155   if (!type2format[i].type) {
156     mp_msg(MSGT_DEMUX, MSGL_INFO, "[demux_mf] unknown input file type.\n" );
157     free(mf);
158     return NULL;
159   }
160   sh_video->format = type2format[i].format;
161
162   sh_video->disp_w = mf_w;
163   sh_video->disp_h = mf_h;
164   sh_video->fps = mf_fps;
165   sh_video->frametime = 1 / sh_video->fps;
166
167   // emulate BITMAPINFOHEADER:
168   sh_video->bih=calloc(1, sizeof(*sh_video->bih));
169   sh_video->bih->biSize=40;
170   sh_video->bih->biWidth = mf_w;
171   sh_video->bih->biHeight = mf_h;
172   sh_video->bih->biPlanes=1;
173   sh_video->bih->biBitCount=24;
174   sh_video->bih->biCompression=sh_video->format;
175   sh_video->bih->biSizeImage=sh_video->bih->biWidth*sh_video->bih->biHeight*3;
176
177   /* disable seeking */
178 //  demuxer->seekable = 0;
179
180   demuxer->priv=(void*)mf;
181
182   return demuxer;
183 }
184
185 static void demux_close_mf(demuxer_t* demuxer) {
186   mf_t *mf = demuxer->priv;
187
188   free(mf);
189 }
190
191 static int demux_control_mf(demuxer_t *demuxer, int cmd, void *arg) {
192   mf_t *mf = (mf_t *)demuxer->priv;
193   sh_video_t *sh_video = demuxer->video->sh;
194
195   switch(cmd) {
196     case DEMUXER_CTRL_GET_TIME_LENGTH:
197       *((double *)arg) = (double)mf->nr_of_files / sh_video->fps;
198       return DEMUXER_CTRL_OK;
199
200     case DEMUXER_CTRL_GET_PERCENT_POS:
201       if (mf->nr_of_files <= 1)
202         return DEMUXER_CTRL_DONTKNOW;
203       *((int *)arg) = 100 * mf->curr_frame / (mf->nr_of_files - 1);
204       return DEMUXER_CTRL_OK;
205
206     default:
207       return DEMUXER_CTRL_NOTIMPL;
208   }
209 }
210
211 const demuxer_desc_t demuxer_desc_mf = {
212   "mf demuxer",
213   "mf",
214   "MF",
215   "?",
216   "multiframe?, pictures demuxer",
217   DEMUXER_TYPE_MF,
218   0, // no autodetect
219   NULL,
220   demux_mf_fill_buffer,
221   demux_open_mf,
222   demux_close_mf,
223   demux_seek_mf,
224   demux_control_mf
225 };