373637167b723484cc03ad81db1526385762c478
[vlc.git] / modules / mux / ogg.c
1 /*****************************************************************************
2  * ogg.c: ogg muxer module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001, 2002, 2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_sout.h>
36 #include <vlc_block.h>
37 #include <vlc_codecs.h>
38
39 #include <ogg/ogg.h>
40
41 /*****************************************************************************
42  * Module descriptor
43  *****************************************************************************/
44 static int  Open   ( vlc_object_t * );
45 static void Close  ( vlc_object_t * );
46
47 vlc_module_begin ()
48     set_description( N_("Ogg/OGM muxer") )
49     set_capability( "sout mux", 10 )
50     set_category( CAT_SOUT )
51     set_subcategory( SUBCAT_SOUT_MUX )
52     add_shortcut( "ogg" )
53     add_shortcut( "ogm" )
54     set_callbacks( Open, Close )
55 vlc_module_end ()
56
57
58 /*****************************************************************************
59  * Exported prototypes
60  *****************************************************************************/
61 static int Control  ( sout_mux_t *, int, va_list );
62 static int AddStream( sout_mux_t *, sout_input_t * );
63 static int DelStream( sout_mux_t *, sout_input_t * );
64 static int Mux      ( sout_mux_t * );
65 static int MuxBlock ( sout_mux_t *, sout_input_t * );
66
67 static block_t *OggCreateHeader( sout_mux_t * );
68 static block_t *OggCreateFooter( sout_mux_t * );
69
70 /*****************************************************************************
71  * Misc declarations
72  *****************************************************************************/
73
74 /* Structures used for OggDS headers used in ogm files */
75
76 #define PACKET_TYPE_HEADER   0x01
77 #define PACKET_TYPE_COMMENT  0x03
78 #define PACKET_IS_SYNCPOINT  0x08
79
80 typedef struct
81 #ifdef HAVE_ATTRIBUTE_PACKED
82     __attribute__((__packed__))
83 #endif
84 {
85     int32_t i_width;
86     int32_t i_height;
87 } oggds_header_video_t;
88
89 typedef struct
90 #ifdef HAVE_ATTRIBUTE_PACKED
91     __attribute__((__packed__))
92 #endif
93 {
94     int16_t i_channels;
95     int16_t i_block_align;
96     int32_t i_avgbytespersec;
97 } oggds_header_audio_t;
98
99 typedef struct
100 #ifdef HAVE_ATTRIBUTE_PACKED
101     __attribute__((__packed__))
102 #endif
103 {
104     uint8_t i_packet_type;
105
106     char stream_type[8];
107     char sub_type[4];
108
109     int32_t i_size;
110
111     int64_t i_time_unit;
112     int64_t i_samples_per_unit;
113     int32_t i_default_len;
114
115     int32_t i_buffer_size;
116     int16_t i_bits_per_sample;
117
118     int16_t i_padding_0; /* Because the original is using MSVC packing style */
119
120     union
121     {
122         oggds_header_video_t video;
123         oggds_header_audio_t audio;
124     } header;
125
126     int32_t i_padding_1; /* Because the original is using MSVC packing style */
127
128 } oggds_header_t;
129
130 /*
131  * TODO  move this function to src/stream_output.c (used by nearly all muxers)
132  */
133 static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts )
134 {
135     mtime_t i_dts;
136     int     i_stream, i;
137
138     for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
139     {
140         block_fifo_t  *p_fifo;
141
142         p_fifo = p_mux->pp_inputs[i]->p_fifo;
143
144         /* We don't really need to have anything in the SPU fifo */
145         if( p_mux->pp_inputs[i]->p_fmt->i_cat == SPU_ES &&
146             block_FifoCount( p_fifo ) == 0 ) continue;
147
148         if( block_FifoCount( p_fifo ) )
149         {
150             block_t *p_buf;
151
152             p_buf = block_FifoShow( p_fifo );
153             if( i_stream < 0 || p_buf->i_dts < i_dts )
154             {
155                 i_dts = p_buf->i_dts;
156                 i_stream = i;
157             }
158         }
159         else return -1;
160
161     }
162     if( pi_stream ) *pi_stream = i_stream;
163     if( pi_dts ) *pi_dts = i_dts;
164     return i_stream;
165 }
166
167 /*****************************************************************************
168  * Definitions of structures and functions used by this plugins
169  *****************************************************************************/
170 typedef struct
171 {
172     int i_cat;
173     int i_fourcc;
174
175     int b_new;
176
177     mtime_t i_dts;
178     mtime_t i_length;
179     int     i_packet_no;
180     int     i_serial_no;
181     int     i_keyframe_granule_shift; /* Theora only */
182     int     i_last_keyframe; /* dirac and eventually theora */
183     uint64_t u_last_granulepos; /* Used for correct EOS page */
184     ogg_stream_state os;
185
186     oggds_header_t *p_oggds_header;
187
188 } ogg_stream_t;
189
190 struct sout_mux_sys_t
191 {
192     int     i_streams;
193
194     mtime_t i_start_dts;
195     int     i_next_serial_no;
196
197     /* number of logical streams pending to be added */
198     int i_add_streams;
199
200     /* logical streams pending to be deleted */
201     int i_del_streams;
202     ogg_stream_t **pp_del_streams;
203 };
204
205 static void OggSetDate( block_t *, mtime_t , mtime_t  );
206 static block_t *OggStreamFlush( sout_mux_t *, ogg_stream_state *, mtime_t );
207
208 /*****************************************************************************
209  * Open: Open muxer
210  *****************************************************************************/
211 static int Open( vlc_object_t *p_this )
212 {
213     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
214     sout_mux_sys_t  *p_sys;
215
216     msg_Info( p_mux, "Open" );
217
218     p_sys                 = malloc( sizeof( sout_mux_sys_t ) );
219     if( !p_sys )
220         return VLC_ENOMEM;
221     p_sys->i_streams      = 0;
222     p_sys->i_add_streams  = 0;
223     p_sys->i_del_streams  = 0;
224     p_sys->pp_del_streams = 0;
225
226     p_mux->p_sys        = p_sys;
227     p_mux->pf_control   = Control;
228     p_mux->pf_addstream = AddStream;
229     p_mux->pf_delstream = DelStream;
230     p_mux->pf_mux       = Mux;
231
232     /* First serial number is random.
233      * (Done like this because on win32 you need to seed the random number
234      *  generator once per thread). */
235     srand( (unsigned int)time( NULL ) );
236     p_sys->i_next_serial_no = rand();
237
238     return VLC_SUCCESS;
239 }
240
241 /*****************************************************************************
242  * Close: Finalize ogg bitstream and close muxer
243  *****************************************************************************/
244 static void Close( vlc_object_t * p_this )
245 {
246     sout_mux_t     *p_mux = (sout_mux_t*)p_this;
247     sout_mux_sys_t *p_sys = p_mux->p_sys;
248
249     msg_Info( p_mux, "Close" );
250
251     if( p_sys->i_del_streams )
252     {
253         block_t *p_og = NULL;
254         mtime_t i_dts = -1;
255         int i;
256
257         /* Close the current ogg stream */
258         msg_Dbg( p_mux, "writing footer" );
259         block_ChainAppend( &p_og, OggCreateFooter( p_mux ) );
260
261         /* Remove deleted logical streams */
262         for( i = 0; i < p_sys->i_del_streams; i++ )
263         {
264             i_dts = p_sys->pp_del_streams[i]->i_dts;
265             ogg_stream_clear( &p_sys->pp_del_streams[i]->os );
266             FREENULL( p_sys->pp_del_streams[i]->p_oggds_header );
267             FREENULL( p_sys->pp_del_streams[i] );
268         }
269         FREENULL( p_sys->pp_del_streams );
270         p_sys->i_streams -= p_sys->i_del_streams;
271
272         /* Write footer */
273         OggSetDate( p_og, i_dts, 0 );
274         sout_AccessOutWrite( p_mux->p_access, p_og );
275     }
276
277     free( p_sys );
278 }
279
280 /*****************************************************************************
281  * Control:
282  *****************************************************************************/
283 static int Control( sout_mux_t *p_mux, int i_query, va_list args )
284 {
285     VLC_UNUSED(p_mux);
286     bool *pb_bool;
287     char **ppsz;
288
289    switch( i_query )
290    {
291        case MUX_CAN_ADD_STREAM_WHILE_MUXING:
292            pb_bool = (bool*)va_arg( args, bool * );
293            *pb_bool = true;
294            return VLC_SUCCESS;
295
296        case MUX_GET_ADD_STREAM_WAIT:
297            pb_bool = (bool*)va_arg( args, bool * );
298            *pb_bool = true;
299            return VLC_SUCCESS;
300
301        case MUX_GET_MIME:
302            ppsz = (char**)va_arg( args, char ** );
303            *ppsz = strdup( "application/ogg" );
304            return VLC_SUCCESS;
305
306         default:
307             return VLC_EGENERIC;
308    }
309 }
310 /*****************************************************************************
311  * AddStream: Add an elementary stream to the muxed stream
312  *****************************************************************************/
313 static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
314 {
315     sout_mux_sys_t *p_sys = p_mux->p_sys;
316     ogg_stream_t   *p_stream;
317     uint16_t i_tag;
318
319     msg_Dbg( p_mux, "adding input" );
320
321     p_input->p_sys = p_stream = calloc( 1, sizeof( ogg_stream_t ) );
322     if( !p_stream )
323         return VLC_ENOMEM;
324
325     p_stream->i_cat       = p_input->p_fmt->i_cat;
326     p_stream->i_fourcc    = p_input->p_fmt->i_codec;
327     p_stream->i_serial_no = p_sys->i_next_serial_no++;
328     p_stream->i_packet_no = 0;
329
330     p_stream->p_oggds_header = 0;
331
332     switch( p_input->p_fmt->i_cat )
333     {
334     case VIDEO_ES:
335         if( !p_input->p_fmt->video.i_frame_rate ||
336             !p_input->p_fmt->video.i_frame_rate_base )
337         {
338             msg_Warn( p_mux, "Missing frame rate, assuming 25fps" );
339             p_input->p_fmt->video.i_frame_rate = 25;
340             p_input->p_fmt->video.i_frame_rate_base = 1;
341         }
342
343         switch( p_stream->i_fourcc )
344         {
345         case VLC_CODEC_MP4V:
346         case VLC_CODEC_MPGV:
347         case VLC_CODEC_DIV3:
348         case VLC_CODEC_MJPG:
349         case VLC_CODEC_WMV1:
350         case VLC_CODEC_WMV2:
351         case VLC_CODEC_WMV3:
352         case VLC_CODEC_SNOW:
353             p_stream->p_oggds_header = calloc( 1, sizeof(oggds_header_t) );
354             if( !p_stream->p_oggds_header )
355             {
356                 free( p_stream );
357                 return VLC_ENOMEM;
358             }
359             p_stream->p_oggds_header->i_packet_type = PACKET_TYPE_HEADER;
360
361             memcpy( p_stream->p_oggds_header->stream_type, "video", 5 );
362             if( p_stream->i_fourcc == VLC_CODEC_MP4V )
363             {
364                 memcpy( p_stream->p_oggds_header->sub_type, "XVID", 4 );
365             }
366             else if( p_stream->i_fourcc == VLC_CODEC_DIV3 )
367             {
368                 memcpy( p_stream->p_oggds_header->sub_type, "DIV3", 4 );
369             }
370             else
371             {
372                 memcpy( p_stream->p_oggds_header->sub_type,
373                         &p_stream->i_fourcc, 4 );
374             }
375             SetDWLE( &p_stream->p_oggds_header->i_size,
376                      sizeof( oggds_header_t ) - 1 );
377             SetQWLE( &p_stream->p_oggds_header->i_time_unit,
378                      INT64_C(10000000) * p_input->p_fmt->video.i_frame_rate_base /
379                      (int64_t)p_input->p_fmt->video.i_frame_rate );
380             SetQWLE( &p_stream->p_oggds_header->i_samples_per_unit, 1 );
381             SetDWLE( &p_stream->p_oggds_header->i_default_len, 1 ); /* ??? */
382             SetDWLE( &p_stream->p_oggds_header->i_buffer_size, 1024*1024 );
383             SetWLE( &p_stream->p_oggds_header->i_bits_per_sample, 0 );
384             SetDWLE( &p_stream->p_oggds_header->header.video.i_width,
385                      p_input->p_fmt->video.i_width );
386             SetDWLE( &p_stream->p_oggds_header->header.video.i_height,
387                      p_input->p_fmt->video.i_height );
388             msg_Dbg( p_mux, "%4.4s stream", (char *)&p_stream->i_fourcc );
389             break;
390
391         case VLC_CODEC_DIRAC:
392             msg_Dbg( p_mux, "dirac stream" );
393             break;
394
395         case VLC_CODEC_THEORA:
396             msg_Dbg( p_mux, "theora stream" );
397             break;
398
399         default:
400             FREENULL( p_input->p_sys );
401             return VLC_EGENERIC;
402         }
403         break;
404
405     case AUDIO_ES:
406         switch( p_stream->i_fourcc )
407         {
408         case VLC_CODEC_VORBIS:
409             msg_Dbg( p_mux, "vorbis stream" );
410             break;
411
412         case VLC_CODEC_SPEEX:
413             msg_Dbg( p_mux, "speex stream" );
414             break;
415
416         case VLC_CODEC_FLAC:
417             msg_Dbg( p_mux, "flac stream" );
418             break;
419
420         default:
421             fourcc_to_wf_tag( p_stream->i_fourcc, &i_tag );
422             if( i_tag == WAVE_FORMAT_UNKNOWN )
423             {
424                 FREENULL( p_input->p_sys );
425                 return VLC_EGENERIC;
426             }
427
428             p_stream->p_oggds_header =
429                 malloc( sizeof(oggds_header_t) + p_input->p_fmt->i_extra );
430             if( !p_stream->p_oggds_header )
431             {
432                 free( p_stream );
433                 return VLC_ENOMEM;
434             }
435             memset( p_stream->p_oggds_header, 0, sizeof(oggds_header_t) );
436             p_stream->p_oggds_header->i_packet_type = PACKET_TYPE_HEADER;
437
438             SetDWLE( &p_stream->p_oggds_header->i_size,
439                      sizeof( oggds_header_t ) - 1 + p_input->p_fmt->i_extra );
440
441             if( p_input->p_fmt->i_extra )
442             {
443                 memcpy( &p_stream->p_oggds_header[1],
444                         p_input->p_fmt->p_extra, p_input->p_fmt->i_extra );
445             }
446
447             memcpy( p_stream->p_oggds_header->stream_type, "audio", 5 );
448
449             memset( p_stream->p_oggds_header->sub_type, 0, 4 );
450             sprintf( p_stream->p_oggds_header->sub_type, "%-x", i_tag );
451
452             SetQWLE( &p_stream->p_oggds_header->i_time_unit, INT64_C(10000000) );
453             SetDWLE( &p_stream->p_oggds_header->i_default_len, 1 );
454             SetDWLE( &p_stream->p_oggds_header->i_buffer_size, 30*1024 );
455             SetQWLE( &p_stream->p_oggds_header->i_samples_per_unit,
456                      p_input->p_fmt->audio.i_rate );
457             SetWLE( &p_stream->p_oggds_header->i_bits_per_sample,
458                     p_input->p_fmt->audio.i_bitspersample );
459             SetDWLE( &p_stream->p_oggds_header->header.audio.i_channels,
460                      p_input->p_fmt->audio.i_channels );
461             SetDWLE( &p_stream->p_oggds_header->header.audio.i_block_align,
462                      p_input->p_fmt->audio.i_blockalign );
463             SetDWLE( &p_stream->p_oggds_header->header.audio.i_avgbytespersec,
464                      p_input->p_fmt->i_bitrate / 8);
465             msg_Dbg( p_mux, "%4.4s stream", (char *)&p_stream->i_fourcc );
466             break;
467         }
468         break;
469
470     case SPU_ES:
471         switch( p_stream->i_fourcc )
472         {
473         case VLC_CODEC_SUBT:
474             p_stream->p_oggds_header = calloc( 1, sizeof(oggds_header_t) );
475             if( !p_stream->p_oggds_header )
476             {
477                 free( p_stream );
478                 return VLC_ENOMEM;
479             }
480             p_stream->p_oggds_header->i_packet_type = PACKET_TYPE_HEADER;
481
482             memcpy( p_stream->p_oggds_header->stream_type, "text", 4 );
483             msg_Dbg( p_mux, "subtitles stream" );
484             break;
485
486         default:
487             FREENULL( p_input->p_sys );
488             return VLC_EGENERIC;
489         }
490         break;
491     default:
492         FREENULL( p_input->p_sys );
493         return VLC_EGENERIC;
494     }
495
496     p_stream->b_new = true;
497
498     p_sys->i_add_streams++;
499
500     return VLC_SUCCESS;
501 }
502
503 /*****************************************************************************
504  * DelStream: Delete an elementary stream from the muxed stream
505  *****************************************************************************/
506 static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
507 {
508     sout_mux_sys_t *p_sys  = p_mux->p_sys;
509     ogg_stream_t   *p_stream = (ogg_stream_t*)p_input->p_sys;
510     block_t *p_og;
511
512     msg_Dbg( p_mux, "removing input" );
513
514     /* flush all remaining data */
515     if( p_input->p_sys )
516     {
517         if( !p_stream->b_new )
518         {
519             while( block_FifoCount( p_input->p_fifo ) )
520                 MuxBlock( p_mux, p_input );
521         }
522
523         if( !p_stream->b_new &&
524             ( p_og = OggStreamFlush( p_mux, &p_stream->os, 0 ) ) )
525         {
526             OggSetDate( p_og, p_stream->i_dts, p_stream->i_length );
527             sout_AccessOutWrite( p_mux->p_access, p_og );
528         }
529
530         /* move input in delete queue */
531         if( !p_stream->b_new )
532         {
533             p_sys->pp_del_streams = realloc( p_sys->pp_del_streams,
534                                              (p_sys->i_del_streams + 1) *
535                                              sizeof(ogg_stream_t *) );
536             p_sys->pp_del_streams[p_sys->i_del_streams++] = p_stream;
537         }
538         else
539         {
540             /* wasn't already added so get rid of it */
541             FREENULL( p_stream->p_oggds_header );
542             FREENULL( p_stream );
543             p_sys->i_add_streams--;
544         }
545     }
546
547     p_input->p_sys = NULL;
548
549     return 0;
550 }
551
552 /*****************************************************************************
553  * Ogg bitstream manipulation routines
554  *****************************************************************************/
555 static block_t *OggStreamFlush( sout_mux_t *p_mux,
556                                 ogg_stream_state *p_os, mtime_t i_pts )
557 {
558     (void)p_mux;
559     block_t *p_og, *p_og_first = NULL;
560     ogg_page og;
561
562     while( ogg_stream_flush( p_os, &og ) )
563     {
564         /* Flush all data */
565         p_og = block_New( p_mux, og.header_len + og.body_len );
566
567         memcpy( p_og->p_buffer, og.header, og.header_len );
568         memcpy( p_og->p_buffer + og.header_len, og.body, og.body_len );
569         p_og->i_dts     = 0;
570         p_og->i_pts     = i_pts;
571         p_og->i_length  = 0;
572
573         i_pts = 0; // write it only once
574
575         block_ChainAppend( &p_og_first, p_og );
576     }
577
578     return p_og_first;
579 }
580
581 static block_t *OggStreamPageOut( sout_mux_t *p_mux,
582                                   ogg_stream_state *p_os, mtime_t i_pts )
583 {
584     (void)p_mux;
585     block_t *p_og, *p_og_first = NULL;
586     ogg_page og;
587
588     while( ogg_stream_pageout( p_os, &og ) )
589     {
590         /* Flush all data */
591         p_og = block_New( p_mux, og.header_len + og.body_len );
592
593         memcpy( p_og->p_buffer, og.header, og.header_len );
594         memcpy( p_og->p_buffer + og.header_len, og.body, og.body_len );
595         p_og->i_dts     = 0;
596         p_og->i_pts     = i_pts;
597         p_og->i_length  = 0;
598
599         i_pts = 0; // write them only once
600
601         block_ChainAppend( &p_og_first, p_og );
602     }
603
604     return p_og_first;
605 }
606
607 static block_t *OggCreateHeader( sout_mux_t *p_mux )
608 {
609     block_t *p_hdr = NULL;
610     block_t *p_og = NULL;
611     ogg_packet op;
612     uint8_t *p_extra;
613     int i, i_extra;
614
615     /* Write header for each stream. All b_o_s (beginning of stream) packets
616      * must appear first in the ogg stream so we take care of them first. */
617     for( i = 0; i < p_mux->i_nb_inputs; i++ )
618     {
619         sout_input_t *p_input = p_mux->pp_inputs[i];
620         ogg_stream_t *p_stream = (ogg_stream_t*)p_input->p_sys;
621         p_stream->b_new = false;
622
623         msg_Dbg( p_mux, "creating header for %4.4s",
624                  (char *)&p_stream->i_fourcc );
625
626         ogg_stream_init( &p_stream->os, p_stream->i_serial_no );
627         p_stream->i_packet_no = 0;
628
629         if( p_stream->i_fourcc == VLC_CODEC_VORBIS ||
630             p_stream->i_fourcc == VLC_CODEC_SPEEX ||
631             p_stream->i_fourcc == VLC_CODEC_THEORA )
632         {
633             /* First packet in order: vorbis/speex/theora info */
634             p_extra = p_input->p_fmt->p_extra;
635             i_extra = p_input->p_fmt->i_extra;
636
637             op.bytes = *(p_extra++) << 8;
638             op.bytes |= (*(p_extra++) & 0xFF);
639             op.packet = p_extra;
640             i_extra -= (op.bytes + 2);
641             if( i_extra < 0 )
642             {
643                 msg_Err( p_mux, "header data corrupted");
644                 op.bytes += i_extra;
645             }
646
647             op.b_o_s  = 1;
648             op.e_o_s  = 0;
649             op.granulepos = 0;
650             op.packetno = p_stream->i_packet_no++;
651             ogg_stream_packetin( &p_stream->os, &op );
652             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
653
654             /* Get keyframe_granule_shift for theora granulepos calculation */
655             if( p_stream->i_fourcc == VLC_CODEC_THEORA )
656             {
657                 int i_keyframe_frequency_force =
658                       1 << ((op.packet[40] << 6 >> 3) | (op.packet[41] >> 5));
659
660                 /* granule_shift = i_log( frequency_force -1 ) */
661                 p_stream->i_keyframe_granule_shift = 0;
662                 i_keyframe_frequency_force--;
663                 while( i_keyframe_frequency_force )
664                 {
665                     p_stream->i_keyframe_granule_shift++;
666                     i_keyframe_frequency_force >>= 1;
667                 }
668             }
669         }
670         else if( p_stream->i_fourcc == VLC_CODEC_DIRAC )
671         {
672             op.packet = p_input->p_fmt->p_extra;
673             op.bytes  = p_input->p_fmt->i_extra;
674             op.b_o_s  = 1;
675             op.e_o_s  = 0;
676             op.granulepos = ~0;
677             op.packetno = p_stream->i_packet_no++;
678             ogg_stream_packetin( &p_stream->os, &op );
679             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
680         }
681         else if( p_stream->i_fourcc == VLC_CODEC_FLAC )
682         {
683             /* flac stream marker (yeah, only that in the 1st packet) */
684             op.packet = (unsigned char *)"fLaC";
685             op.bytes  = 4;
686             op.b_o_s  = 1;
687             op.e_o_s  = 0;
688             op.granulepos = 0;
689             op.packetno = p_stream->i_packet_no++;
690             ogg_stream_packetin( &p_stream->os, &op );
691             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
692         }
693         else if( p_stream->p_oggds_header )
694         {
695             /* ds header */
696             op.packet = (uint8_t*)p_stream->p_oggds_header;
697             op.bytes  = p_stream->p_oggds_header->i_size + 1;
698             op.b_o_s  = 1;
699             op.e_o_s  = 0;
700             op.granulepos = 0;
701             op.packetno = p_stream->i_packet_no++;
702             ogg_stream_packetin( &p_stream->os, &op );
703             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
704         }
705
706         block_ChainAppend( &p_hdr, p_og );
707     }
708
709     /* Take care of the non b_o_s headers */
710     for( i = 0; i < p_mux->i_nb_inputs; i++ )
711     {
712         sout_input_t *p_input = p_mux->pp_inputs[i];
713         ogg_stream_t *p_stream = (ogg_stream_t*)p_input->p_sys;
714
715         if( p_stream->i_fourcc == VLC_CODEC_VORBIS ||
716             p_stream->i_fourcc == VLC_CODEC_SPEEX ||
717             p_stream->i_fourcc == VLC_CODEC_THEORA )
718         {
719             /* Special case, headers are already there in the incoming stream.
720              * We need to gather them an mark them as headers. */
721             int j = 2;
722
723             if( p_stream->i_fourcc == VLC_CODEC_SPEEX ) j = 1;
724
725             p_extra = p_input->p_fmt->p_extra;
726             i_extra = p_input->p_fmt->i_extra;
727
728             /* Skip 1 header */
729             op.bytes = *(p_extra++) << 8;
730             op.bytes |= (*(p_extra++) & 0xFF);
731             op.packet = p_extra;
732             p_extra += op.bytes;
733             i_extra -= (op.bytes + 2);
734
735             while( j-- )
736             {
737                 op.bytes = *(p_extra++) << 8;
738                 op.bytes |= (*(p_extra++) & 0xFF);
739                 op.packet = p_extra;
740                 p_extra += op.bytes;
741                 i_extra -= (op.bytes + 2);
742                 if( i_extra < 0 )
743                 {
744                     msg_Err( p_mux, "header data corrupted");
745                     op.bytes += i_extra;
746                 }
747
748                 op.b_o_s  = 0;
749                 op.e_o_s  = 0;
750                 op.granulepos = 0;
751                 op.packetno = p_stream->i_packet_no++;
752                 ogg_stream_packetin( &p_stream->os, &op );
753
754                 p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
755                 block_ChainAppend( &p_hdr, p_og );
756             }
757         }
758         else if( p_stream->i_fourcc != VLC_CODEC_FLAC &&
759                  p_stream->i_fourcc != VLC_CODEC_DIRAC )
760         {
761             uint8_t com[128];
762             int     i_com;
763
764             /* comment */
765             com[0] = PACKET_TYPE_COMMENT;
766             i_com = snprintf( (char *)(com+1), 127,
767                               PACKAGE_VERSION" stream output" )
768                      + 1;
769             op.packet = com;
770             op.bytes  = i_com;
771             op.b_o_s  = 0;
772             op.e_o_s  = 0;
773             op.granulepos = 0;
774             op.packetno = p_stream->i_packet_no++;
775             ogg_stream_packetin( &p_stream->os, &op );
776             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
777             block_ChainAppend( &p_hdr, p_og );
778         }
779
780         /* Special case for mp4v and flac */
781         if( ( p_stream->i_fourcc == VLC_CODEC_MP4V ||
782               p_stream->i_fourcc == VLC_CODEC_FLAC ) &&
783             p_input->p_fmt->i_extra )
784         {
785             /* Send a packet with the VOL data for mp4v
786              * or STREAMINFO for flac */
787             msg_Dbg( p_mux, "writing extra data" );
788             op.bytes  = p_input->p_fmt->i_extra;
789             op.packet = p_input->p_fmt->p_extra;
790             if( p_stream->i_fourcc == VLC_CODEC_FLAC )
791             {
792                 /* Skip the flac stream marker */
793                 op.bytes -= 4;
794                 op.packet+= 4;
795             }
796             op.b_o_s  = 0;
797             op.e_o_s  = 0;
798             op.granulepos = 0;
799             op.packetno = p_stream->i_packet_no++;
800             ogg_stream_packetin( &p_stream->os, &op );
801             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
802             block_ChainAppend( &p_hdr, p_og );
803         }
804     }
805
806     /* set HEADER flag */
807     for( p_og = p_hdr; p_og != NULL; p_og = p_og->p_next )
808     {
809         p_og->i_flags |= BLOCK_FLAG_HEADER;
810     }
811     return p_hdr;
812 }
813
814 static block_t *OggCreateFooter( sout_mux_t *p_mux )
815 {
816     sout_mux_sys_t *p_sys = p_mux->p_sys;
817     block_t *p_hdr = NULL;
818     block_t *p_og;
819     ogg_packet    op;
820     int     i;
821
822     /* flush all remaining data */
823     for( i = 0; i < p_mux->i_nb_inputs; i++ )
824     {
825         ogg_stream_t *p_stream = p_mux->pp_inputs[i]->p_sys;
826
827         /* skip newly added streams */
828         if( p_stream->b_new ) continue;
829
830         if( ( p_og = OggStreamFlush( p_mux, &p_stream->os, 0 ) ) )
831         {
832             OggSetDate( p_og, p_stream->i_dts, p_stream->i_length );
833             sout_AccessOutWrite( p_mux->p_access, p_og );
834         }
835     }
836
837     /* Write eos packets for each stream. */
838     for( i = 0; i < p_mux->i_nb_inputs; i++ )
839     {
840         ogg_stream_t *p_stream = p_mux->pp_inputs[i]->p_sys;
841
842         /* skip newly added streams */
843         if( p_stream->b_new ) continue;
844
845         op.packet = NULL;
846         op.bytes  = 0;
847         op.b_o_s  = 0;
848         op.e_o_s  = 1;
849         op.granulepos = p_stream->u_last_granulepos;
850         op.packetno = p_stream->i_packet_no++;
851         ogg_stream_packetin( &p_stream->os, &op );
852
853         p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
854         block_ChainAppend( &p_hdr, p_og );
855         ogg_stream_clear( &p_stream->os );
856     }
857
858     for( i = 0; i < p_sys->i_del_streams; i++ )
859     {
860         op.packet = NULL;
861         op.bytes  = 0;
862         op.b_o_s  = 0;
863         op.e_o_s  = 1;
864         op.granulepos = p_sys->pp_del_streams[i]->u_last_granulepos;
865         op.packetno = p_sys->pp_del_streams[i]->i_packet_no++;
866         ogg_stream_packetin( &p_sys->pp_del_streams[i]->os, &op );
867
868         p_og = OggStreamFlush( p_mux, &p_sys->pp_del_streams[i]->os, 0 );
869         block_ChainAppend( &p_hdr, p_og );
870         ogg_stream_clear( &p_sys->pp_del_streams[i]->os );
871     }
872
873     return p_hdr;
874 }
875
876 static void OggSetDate( block_t *p_og, mtime_t i_dts, mtime_t i_length )
877 {
878     int i_count;
879     block_t *p_tmp;
880     mtime_t i_delta;
881
882     for( p_tmp = p_og, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->p_next )
883     {
884         i_count++;
885     }
886
887     if( i_count == 0 ) return; /* ignore. */
888
889     i_delta = i_length / i_count;
890
891     for( p_tmp = p_og; p_tmp != NULL; p_tmp = p_tmp->p_next )
892     {
893         p_tmp->i_dts    = i_dts;
894         p_tmp->i_length = i_delta;
895
896         i_dts += i_delta;
897     }
898 }
899
900 /*****************************************************************************
901  * Mux: multiplex available data in input fifos into the Ogg bitstream
902  *****************************************************************************/
903 static int Mux( sout_mux_t *p_mux )
904 {
905     sout_mux_sys_t *p_sys = p_mux->p_sys;
906     block_t        *p_og = NULL;
907     int            i_stream;
908     mtime_t        i_dts;
909
910     if( p_sys->i_add_streams || p_sys->i_del_streams )
911     {
912         /* Open new ogg stream */
913         if( MuxGetStream( p_mux, &i_stream, &i_dts) < 0 )
914         {
915             msg_Dbg( p_mux, "waiting for data..." );
916             return VLC_SUCCESS;
917         }
918
919         if( p_sys->i_streams )
920         {
921             /* Close current ogg stream */
922             int i;
923
924             msg_Dbg( p_mux, "writing footer" );
925             block_ChainAppend( &p_og, OggCreateFooter( p_mux ) );
926
927             /* Remove deleted logical streams */
928             for( i = 0; i < p_sys->i_del_streams; i++ )
929             {
930                 FREENULL( p_sys->pp_del_streams[i]->p_oggds_header );
931                 FREENULL( p_sys->pp_del_streams[i] );
932             }
933             FREENULL( p_sys->pp_del_streams );
934             p_sys->i_streams = 0;
935         }
936
937         msg_Dbg( p_mux, "writing header" );
938         p_sys->i_start_dts = i_dts;
939         p_sys->i_streams = p_mux->i_nb_inputs;
940         p_sys->i_del_streams = 0;
941         p_sys->i_add_streams = 0;
942         block_ChainAppend( &p_og, OggCreateHeader( p_mux ) );
943
944         /* Write header and/or footer */
945         OggSetDate( p_og, i_dts, 0 );
946         sout_AccessOutWrite( p_mux->p_access, p_og );
947         p_og = NULL;
948     }
949
950     for( ;; )
951     {
952         if( MuxGetStream( p_mux, &i_stream, 0 ) < 0 ) return VLC_SUCCESS;
953         MuxBlock( p_mux, p_mux->pp_inputs[i_stream] );
954     }
955
956     return VLC_SUCCESS;
957 }
958
959 static int MuxBlock( sout_mux_t *p_mux, sout_input_t *p_input )
960 {
961     sout_mux_sys_t *p_sys = p_mux->p_sys;
962     ogg_stream_t *p_stream = (ogg_stream_t*)p_input->p_sys;
963     block_t *p_data = block_FifoGet( p_input->p_fifo );
964     block_t *p_og = NULL;
965     ogg_packet op;
966
967     if( p_stream->i_fourcc != VLC_CODEC_VORBIS &&
968         p_stream->i_fourcc != VLC_CODEC_FLAC &&
969         p_stream->i_fourcc != VLC_CODEC_SPEEX &&
970         p_stream->i_fourcc != VLC_CODEC_THEORA &&
971         p_stream->i_fourcc != VLC_CODEC_DIRAC )
972     {
973         p_data = block_Realloc( p_data, 1, p_data->i_buffer );
974         p_data->p_buffer[0] = PACKET_IS_SYNCPOINT;      // FIXME
975     }
976
977     op.packet   = p_data->p_buffer;
978     op.bytes    = p_data->i_buffer;
979     op.b_o_s    = 0;
980     op.e_o_s    = 0;
981     op.packetno = p_stream->i_packet_no++;
982
983     if( p_stream->i_cat == AUDIO_ES )
984     {
985         if( p_stream->i_fourcc == VLC_CODEC_VORBIS ||
986             p_stream->i_fourcc == VLC_CODEC_FLAC ||
987             p_stream->i_fourcc == VLC_CODEC_SPEEX )
988         {
989             /* number of sample from begining + current packet */
990             op.granulepos =
991                 ( p_data->i_dts - p_sys->i_start_dts + p_data->i_length ) *
992                 (mtime_t)p_input->p_fmt->audio.i_rate / INT64_C(1000000);
993         }
994         else if( p_stream->p_oggds_header )
995         {
996             /* number of sample from begining */
997             op.granulepos = ( p_data->i_dts - p_sys->i_start_dts ) *
998                 p_stream->p_oggds_header->i_samples_per_unit / INT64_C(1000000);
999         }
1000     }
1001     else if( p_stream->i_cat == VIDEO_ES )
1002     {
1003         if( p_stream->i_fourcc == VLC_CODEC_THEORA )
1004         {
1005             /* FIXME, we assume only keyframes */
1006             op.granulepos = ( ( p_data->i_dts - p_sys->i_start_dts ) *
1007                 p_input->p_fmt->video.i_frame_rate /
1008                 p_input->p_fmt->video.i_frame_rate_base /
1009                 INT64_C(1000000) ) << p_stream->i_keyframe_granule_shift;
1010         }
1011         else if( p_stream->i_fourcc == VLC_CODEC_DIRAC )
1012         {
1013             mtime_t dt = (p_data->i_dts - p_sys->i_start_dts + 1)
1014                        * p_input->p_fmt->video.i_frame_rate *2
1015                        / p_input->p_fmt->video.i_frame_rate_base
1016                        / INT64_C(1000000);
1017             mtime_t delay = (p_data->i_pts - p_data->i_dts + 1)
1018                           * p_input->p_fmt->video.i_frame_rate *2
1019                           / p_input->p_fmt->video.i_frame_rate_base
1020                           / INT64_C(1000000);
1021             if( p_data->i_flags & BLOCK_FLAG_TYPE_I )
1022                 p_stream->i_last_keyframe = dt;
1023             mtime_t dist = dt - p_stream->i_last_keyframe;
1024             op.granulepos = dt << 31 | (dist&0xff00) << 14
1025                           | (delay&0x1fff) << 9 | (dist&0xff);
1026         }
1027         else if( p_stream->p_oggds_header )
1028             op.granulepos = ( p_data->i_dts - p_sys->i_start_dts ) * INT64_C(10) /
1029                 p_stream->p_oggds_header->i_time_unit;
1030     }
1031     else if( p_stream->i_cat == SPU_ES )
1032     {
1033         /* granulepos is in millisec */
1034         op.granulepos = ( p_data->i_dts - p_sys->i_start_dts ) / 1000;
1035     }
1036
1037     p_stream->u_last_granulepos = op.granulepos;
1038     ogg_stream_packetin( &p_stream->os, &op );
1039
1040     if( p_stream->i_cat == SPU_ES ||
1041         p_stream->i_fourcc == VLC_CODEC_SPEEX ||
1042         p_stream->i_fourcc == VLC_CODEC_DIRAC )
1043     {
1044         /* Subtitles or Speex packets are quite small so they
1045          * need to be flushed to be sent on time */
1046         /* The OggDirac mapping suggests ever so strongly that a
1047          * page flush occurs after each OggDirac packet, so to make
1048          * the timestamps unambiguous */
1049         p_og = OggStreamFlush( p_mux, &p_stream->os, p_data->i_dts );
1050     }
1051     else
1052     {
1053         p_og = OggStreamPageOut( p_mux, &p_stream->os, p_data->i_dts );
1054     }
1055
1056     if( p_og )
1057     {
1058         OggSetDate( p_og, p_stream->i_dts, p_stream->i_length );
1059         p_stream->i_dts = -1;
1060         p_stream->i_length = 0;
1061
1062         sout_AccessOutWrite( p_mux->p_access, p_og );
1063     }
1064     else
1065     {
1066         if( p_stream->i_dts < 0 )
1067         {
1068             p_stream->i_dts = p_data->i_dts;
1069         }
1070         p_stream->i_length += p_data->i_length;
1071     }
1072
1073     block_Release( p_data );
1074     return VLC_SUCCESS;
1075 }