f614da2c872c4c4717d8427da3f98a1f810d2754
[vlc.git] / modules / demux / mjpeg.c
1 /*****************************************************************************
2  * mjpeg.c : demuxes mjpeg webcam http streams
3  *****************************************************************************
4  * Copyright (C) 2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Henry Jen (slowhog) <henryjen@ztune.net>
8  *          Derk-Jan Hartman (thedj)
9  *          Sigmund Augdal (Dnumgis)
10  *          Laurent Aimar <fenrir@via.ecp.fr>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #include <stdlib.h>                                      /* malloc(), free() */
31
32 #include <vlc/vlc.h>
33 #include <vlc/input.h>
34
35 #include <codecs.h>
36
37 /*****************************************************************************
38  * Module descriptor
39  *****************************************************************************/
40 static int  Open ( vlc_object_t * );
41 static void Close( vlc_object_t * );
42
43 #define FPS_TEXT N_("Frames per Second")
44 #define FPS_LONGTEXT N_("This is the desired frame rate when " \
45     "playing MJPEG from a file. Use 0 (this is the default value) for a " \
46     "live stream (from a camera).")
47
48 vlc_module_begin();
49     set_shortname( "MJPEG");
50     set_description( _("M-JPEG camera demuxer") );
51     set_capability( "demux2", 5 );
52     set_callbacks( Open, Close );
53     set_category( CAT_INPUT );
54     set_subcategory( SUBCAT_INPUT_DEMUX );
55     add_float( "mjpeg-fps", 0.0, NULL, FPS_TEXT, FPS_LONGTEXT, VLC_FALSE );
56 vlc_module_end();
57
58 /*****************************************************************************
59  * Local prototypes
60  *****************************************************************************/
61 static int MimeDemux( demux_t * );
62 static int MjpgDemux( demux_t * );
63 static int Control( demux_t *, int i_query, va_list args );
64
65 struct demux_sys_t
66 {
67     es_format_t     fmt;
68     es_out_id_t     *p_es;
69
70     vlc_bool_t      b_still;
71     mtime_t         i_still_end;
72     mtime_t         i_still_length;
73
74     mtime_t         i_time;
75     mtime_t         i_frame_length;
76     char            *psz_separator;
77     int             i_frame_size_estimate;
78     uint8_t         *p_peek;
79     int             i_data_peeked;
80 };
81
82 /*****************************************************************************
83  * Peek: Helper function to peek data with incremental size.
84  * \return VLC_FALSE if peek no more data, VLC_TRUE otherwise.
85  *****************************************************************************/
86 static vlc_bool_t Peek( demux_t *p_demux, vlc_bool_t b_first )
87 {
88     int i_data;
89     demux_sys_t *p_sys = p_demux->p_sys;
90
91     if( b_first )
92     {
93         p_sys->i_data_peeked = 0;
94     }
95     else if( p_sys->i_data_peeked == p_sys->i_frame_size_estimate )
96     {
97         p_sys->i_frame_size_estimate += 5120;
98     }
99     i_data = stream_Peek( p_demux->s, &p_sys->p_peek,
100                           p_sys->i_frame_size_estimate );
101     if( i_data == p_sys->i_data_peeked )
102     {
103         msg_Warn( p_demux, "no more data" );
104         return VLC_FALSE;
105     }
106     p_sys->i_data_peeked = i_data;
107     if( i_data <= 0 )
108     {
109         msg_Warn( p_demux, "cannot peek data" );
110         return VLC_FALSE;
111     }
112     return VLC_TRUE;
113 }
114
115 /*****************************************************************************
116  * GetLine: Internal function used to dup a line of string from the buffer
117  *****************************************************************************/
118 static char* GetLine( demux_t *p_demux, int *p_pos )
119 {
120     demux_sys_t *p_sys = p_demux->p_sys;
121     uint8_t     *p_buf;
122     int         i_size;
123     int         i;
124     char        *p_line;
125
126     while( *p_pos > p_sys->i_data_peeked )
127     {
128         if( ! Peek( p_demux, VLC_FALSE ) )
129         {
130             return NULL;
131         }
132     }
133     p_buf = p_sys->p_peek + *p_pos;
134     i_size = p_sys->i_data_peeked - *p_pos;
135     i = 0;
136     while( p_buf[i] != '\n' )
137     {
138         i++;
139         if( i == i_size )
140         {
141             if( ! Peek( p_demux, VLC_FALSE ) )
142             {
143                 return NULL;
144             }
145         }
146         p_buf = p_sys->p_peek + *p_pos;
147         i_size = p_sys->i_data_peeked - *p_pos;
148     }
149     *p_pos += ( i + 1 );
150     if( i > 0 && '\r' == p_buf[i - 1] )
151     {
152         i--;
153     }
154     p_line = malloc( i + 1 );
155     if( NULL == p_line )
156     {
157         msg_Err( p_demux, "out of memory" );
158         return NULL;
159     }
160     strncpy ( p_line, p_buf, i );
161     p_line[i] = '\0';
162 //    msg_Dbg( p_demux, "i = %d, pos = %d, %s", i, *p_pos, p_line );
163     return p_line;
164 }
165
166 /*****************************************************************************
167  * CheckMimeHeader: Internal function used to verify and skip mime header
168  * \param p_header_size Return size of MIME header, 0 if no MIME header
169  * detected, minus value if error
170  * \return VLC_TRUE if content type is image/jpeg, VLC_FALSE otherwise
171  *****************************************************************************/
172 static vlc_bool_t CheckMimeHeader( demux_t *p_demux, int *p_header_size )
173 {
174     vlc_bool_t  b_jpeg = VLC_FALSE;
175     int         i_pos;
176     char        *psz_line;
177     char        *p_ch;
178     demux_sys_t *p_sys = p_demux->p_sys;
179
180     if( !Peek( p_demux, VLC_TRUE ) )
181     {
182         msg_Err( p_demux, "cannot peek" );
183         *p_header_size = -1;
184         return VLC_FALSE;
185     }
186     if( p_sys->i_data_peeked < 3)
187     {
188         msg_Err( p_demux, "data shortage" );
189         *p_header_size = -2;
190         return VLC_FALSE;
191     }
192     if( strncmp( (char *)p_sys->p_peek, "--", 2 ) )
193     {
194         *p_header_size = 0;
195         return VLC_FALSE;
196     }
197     i_pos = 2;
198     psz_line = GetLine( p_demux, &i_pos );
199     if( NULL == psz_line )
200     {
201         msg_Err( p_demux, "no EOL" );
202         *p_header_size = -3;
203         return VLC_FALSE;
204     }
205     if( NULL == p_sys->psz_separator )
206     {
207         p_sys->psz_separator = psz_line;
208         msg_Dbg( p_demux, "Multipart MIME detected, using separator: %s",
209                  p_sys->psz_separator );
210     }
211     else
212     {
213         if( strcmp( psz_line, p_sys->psz_separator ) )
214         {
215             msg_Warn( p_demux, "separator %s does not match %s", psz_line,
216                       p_sys->psz_separator );
217         }
218         free( psz_line );
219     }
220     psz_line = GetLine( p_demux, &i_pos );
221     while( psz_line && *psz_line )
222     {
223         if( !strncasecmp( psz_line, "Content-Type:", 13 ) )
224         {
225             p_ch = psz_line + 13;
226             while( *p_ch != '\0' && ( *p_ch == ' ' || *p_ch == '\t' ) ) p_ch++;
227             if( strncasecmp( p_ch, "image/jpeg", 10 ) )
228             {
229                 msg_Warn( p_demux, "%s, image/jpeg is expected", psz_line );
230                 b_jpeg = VLC_FALSE;
231             }
232             else
233             {
234                 b_jpeg = VLC_TRUE;
235             }
236         }
237         else
238         {
239             msg_Dbg( p_demux, "discard MIME header: %s", psz_line );
240         }
241         free( psz_line );
242         psz_line = GetLine( p_demux, &i_pos );
243     }
244
245     if( NULL == psz_line )
246     {
247         msg_Err( p_demux, "no EOL" );
248         *p_header_size = -3;
249         return VLC_FALSE;
250     }
251
252     free( psz_line );
253
254     *p_header_size = i_pos;
255     return b_jpeg;
256 }
257
258 static int SendBlock( demux_t *p_demux, int i )
259 {
260     demux_sys_t *p_sys = p_demux->p_sys;
261     block_t     *p_block;
262
263     if( ( p_block = stream_Block( p_demux->s, i ) ) == NULL )
264     {
265         msg_Warn( p_demux, "cannot read data" );
266         return 0;
267     }
268
269     if( !p_sys->i_frame_length || !p_sys->i_time )
270     {
271         p_sys->i_time = p_block->i_dts = p_block->i_pts = mdate();
272     }
273     else
274     {
275         p_block->i_dts = p_block->i_pts = p_sys->i_time;
276         p_sys->i_time += p_sys->i_frame_length;
277     }
278
279     /* set PCR */
280     es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts );
281     es_out_Send( p_demux->out, p_sys->p_es, p_block );
282
283     if( p_sys->b_still )
284     {
285         p_sys->i_still_end = mdate() + p_sys->i_still_length;
286     }
287
288     return 1;
289 }
290
291 /*****************************************************************************
292  * Open: check file and initializes structures
293  *****************************************************************************/
294 static int Open( vlc_object_t * p_this )
295 {
296     demux_t     *p_demux = (demux_t*)p_this;
297     demux_sys_t *p_sys;
298     int         i_size;
299     int         b_matched = VLC_FALSE;
300     vlc_value_t val;
301     char *psz_ext;
302
303     p_demux->pf_control = Control;
304     p_demux->p_sys      = p_sys = malloc( sizeof( demux_sys_t ) );
305     p_sys->p_es         = NULL;
306     p_sys->i_time       = 0;
307
308     p_sys->psz_separator = NULL;
309     p_sys->i_frame_size_estimate = 15 * 1024;
310
311     b_matched = CheckMimeHeader( p_demux, &i_size);
312     if( b_matched )
313     {
314         p_demux->pf_demux = MimeDemux;
315         stream_Read( p_demux->s, NULL, i_size );
316     }
317     else if( 0 == i_size )
318     {
319         /* 0xffd8 identify a JPEG SOI */
320         if( p_sys->p_peek[0] == 0xFF && p_sys->p_peek[1] == 0xD8 )
321         {
322             msg_Dbg( p_demux, "JPEG SOI marker detected" );
323             p_demux->pf_demux = MjpgDemux;
324         }
325         else
326         {
327             goto error;
328         }
329     }
330     else
331     {
332         goto error;
333     }
334
335
336     var_Create( p_demux, "mjpeg-fps", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
337     var_Get( p_demux, "mjpeg-fps", &val );
338     p_sys->i_frame_length = 0;
339
340     /* Check for jpeg file extension */
341     p_sys->b_still = VLC_FALSE;
342     p_sys->i_still_end = 0;
343     psz_ext = strrchr( p_demux->psz_path, '.' );
344     if( psz_ext && ( !strcasecmp( psz_ext, ".jpeg" ) ||
345                      !strcasecmp( psz_ext, ".jpg" ) ) )
346     {
347         p_sys->b_still = VLC_TRUE;
348         if( val.f_float)
349         {
350             p_sys->i_still_length =1000000.0 / val.f_float;
351         }
352         else
353         {
354             /* Defaults to 1fps */
355             p_sys->i_still_length = 1000000;
356         }
357     }
358     else if ( val.f_float )
359     {
360         p_sys->i_frame_length = 1000000.0 / val.f_float;
361     }
362
363     es_format_Init( &p_sys->fmt, VIDEO_ES, 0 );
364     p_sys->fmt.i_codec = VLC_FOURCC('m','j','p','g');
365
366     p_sys->p_es = es_out_Add( p_demux->out, &p_sys->fmt );
367     return VLC_SUCCESS;
368
369 error:
370     free( p_sys );
371     return VLC_EGENERIC;
372 }
373
374 /*****************************************************************************
375  * Demux: read packet and send them to decoders
376  *****************************************************************************
377  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
378  *****************************************************************************/
379 static int MjpgDemux( demux_t *p_demux )
380 {
381     demux_sys_t *p_sys = p_demux->p_sys;
382     int i;
383
384     if( p_sys->b_still && p_sys->i_still_end && p_sys->i_still_end < mdate() )
385     {
386         /* Still frame, wait until the pause delay is gone */
387         p_sys->i_still_end = 0;
388     }
389     else if( p_sys->b_still && p_sys->i_still_end )
390     {
391         msleep( 400 );
392         return 1;
393     }
394
395     if( !Peek( p_demux, VLC_TRUE ) )
396     {
397         msg_Warn( p_demux, "cannot peek data" );
398         return 0;
399     }
400     if( p_sys->i_data_peeked < 4 )
401     {
402         msg_Warn( p_demux, "data shortage" );
403         return 0;
404     }
405     i = 3;
406     while( !( 0xFF == p_sys->p_peek[i-1] && 0xD9 == p_sys->p_peek[i] ) )
407     {
408         i++;
409         if( i >= p_sys->i_data_peeked )
410         {
411             msg_Dbg( p_demux, "did not find JPEG EOI in %d bytes",
412                      p_sys->i_data_peeked );
413             if( !Peek( p_demux, VLC_FALSE ) )
414             {
415                 msg_Warn( p_demux, "no more data is available at the moment" );
416                 return 0;
417             }
418         }
419     }
420     i++;
421
422     msg_Dbg( p_demux, "JPEG EOI detected at %d", i );
423     return SendBlock( p_demux, i );
424 }
425
426 static int MimeDemux( demux_t *p_demux )
427 {
428     demux_sys_t *p_sys = p_demux->p_sys;
429     int         i_size, i;
430     vlc_bool_t  b_match;
431     vlc_bool_t  b_done;
432
433     b_match = CheckMimeHeader( p_demux, &i_size );
434     if( i_size > 0 )
435     {
436         stream_Read( p_demux->s, NULL, i_size );
437     }
438     else if( i_size < 0 )
439     {
440         return 0;
441     }
442     else
443     {
444         // No MIME header, assume OK
445         b_match = VLC_TRUE;
446     }
447
448     if( !Peek( p_demux, VLC_TRUE ) )
449     {
450         msg_Warn( p_demux, "cannot peek data" );
451         return 0;
452     }
453     i = 0;
454     i_size = strlen( p_sys->psz_separator ) + 2;
455     if( p_sys->i_data_peeked < i_size )
456     {
457         msg_Warn( p_demux, "data shortage" );
458         return 0;
459     }
460     b_done = VLC_FALSE;
461     while( !b_done )
462     {
463         while( !( p_sys->p_peek[i] == '-' && p_sys->p_peek[i+1] == '-' ) )
464         {
465             i++;
466             i_size++;
467             if( i_size >= p_sys->i_data_peeked )
468             {
469                 msg_Dbg( p_demux, "MIME boundary not found in %d bytes of "
470                          "data", p_sys->i_data_peeked );
471
472                 if( !Peek( p_demux, VLC_FALSE ) )
473                 {
474                     msg_Warn( p_demux, "no more data is available at the "
475                               "moment" );
476                     return 0;
477                 }
478             }
479         }
480         if( !strncmp( p_sys->psz_separator, (char *)(p_sys->p_peek + i + 2),
481                       strlen( p_sys->psz_separator ) ) )
482         {
483             b_done = VLC_TRUE;
484         }
485         else
486         {
487             i++;
488             i_size++;
489         }
490     }
491
492     if( !b_match )
493     {
494         msg_Err( p_demux, "discard non-JPEG part" );
495         stream_Read( p_demux->s, NULL, i );
496         return 0;
497     }
498
499     return SendBlock( p_demux, i );
500 }
501
502 /*****************************************************************************
503  * Close: frees unused data
504  *****************************************************************************/
505 static void Close ( vlc_object_t * p_this )
506 {
507     demux_t     *p_demux = (demux_t*)p_this;
508     demux_sys_t *p_sys  = p_demux->p_sys;
509
510     if( p_sys->psz_separator )
511     {
512         free( p_sys->psz_separator );
513     }
514     free( p_sys );
515 }
516
517 /*****************************************************************************
518  * Control:
519  *****************************************************************************/
520 static int Control( demux_t *p_demux, int i_query, va_list args )
521 {
522     return demux2_vaControlHelper( p_demux->s, 0, 0, 0, 0, i_query, args );
523 }