开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
ogg.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：32k
源码类别：

多媒体

开发平台：

MultiPlatform

ogg.c：源码内容
  1. /*****************************************************************************
  2.  * ogg.c: ogg muxer module for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 VideoLAN
  5.  * $Id: ogg.c 8566 2004-08-29 11:42:43Z gbazin $
  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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #include <stdlib.h>
  29. #include <string.h>
  31. #ifdef HAVE_TIME_H
  32. #   include <time.h>
  33. #endif
  35. #include <vlc/vlc.h>
  36. #include <vlc/input.h>
  37. #include <vlc/sout.h>
  39. #include "codecs.h"
  41. #include <ogg/ogg.h>
  43. /*****************************************************************************
  44.  * Module descriptor
  45.  *****************************************************************************/
  46. static int  Open   ( vlc_object_t * );
  47. static void Close  ( vlc_object_t * );
  49. vlc_module_begin();
  50.     set_description( _("Ogg/ogm muxer") );
  51.     set_capability( "sout mux", 10 );
  52.     add_shortcut( "ogg" );
  53.     add_shortcut( "ogm" );
  54.     set_callbacks( Open, Close );
  55. vlc_module_end();
  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 * );
  67. static block_t *OggCreateHeader( sout_mux_t *, mtime_t );
  68. static block_t *OggCreateFooter( sout_mux_t *, mtime_t );
  70. /*****************************************************************************
  71.  * Misc declarations
  72.  *****************************************************************************/
  73. #define FREE( p ) if( p ) { free( p ); (p) = NULL; }
  75. /* Structures used for OggDS headers used in ogm files */
  77. #define PACKET_TYPE_HEADER   0x01
  78. #define PACKET_TYPE_COMMENT  0x03
  79. #define PACKET_IS_SYNCPOINT  0x08
  81. typedef struct
  82. #ifdef HAVE_ATTRIBUTE_PACKED
  83.     __attribute__((__packed__))
  84. #endif
  85. {
  86.     int32_t i_width;
  87.     int32_t i_height;
  88. } oggds_header_video_t;
  90. typedef struct
  91. #ifdef HAVE_ATTRIBUTE_PACKED
  92.     __attribute__((__packed__))
  93. #endif
  94. {
  95.     int16_t i_channels;
  96.     int16_t i_block_align;
  97.     int32_t i_avgbytespersec;
  98. } oggds_header_audio_t;
  100. typedef struct
  101. #ifdef HAVE_ATTRIBUTE_PACKED
  102.     __attribute__((__packed__))
  103. #endif
  104. {
  105.     uint8_t i_packet_type;
  107.     char stream_type[8];
  108.     char sub_type[4];
  110.     int32_t i_size;
  112.     int64_t i_time_unit;
  113.     int64_t i_samples_per_unit;
  114.     int32_t i_default_len;
  116.     int32_t i_buffer_size;
  117.     int16_t i_bits_per_sample;
  119.     int16_t i_padding_0; /* Because the original is using MSVC packing style */
  121.     union
  122.     {
  123.         oggds_header_video_t video;
  124.         oggds_header_audio_t audio;
  125.     } header;
  127.     int32_t i_padding_1; /* Because the original is using MSVC packing style */
  129. } oggds_header_t;
  131. /*
  132.  * TODO  move this function to src/stream_output.c (used by nearly all muxers)
  133.  */
  134. static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts )
  135. {
  136.     mtime_t i_dts;
  137.     int     i_stream;
  138.     int     i;
  140.     for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
  141.     {
  142.         block_fifo_t  *p_fifo;
  144.         p_fifo = p_mux->pp_inputs[i]->p_fifo;
  146.         /* We don't really need to have anything in the SPU fifo */
  147.         if( p_mux->pp_inputs[i]->p_fmt->i_cat == SPU_ES &&
  148.             p_fifo->i_depth == 0 ) continue;
  150.         if( p_fifo->i_depth )
  151.         {
  152.             block_t *p_buf;
  154.             p_buf = block_FifoShow( p_fifo );
  155.             if( i_stream < 0 || p_buf->i_dts < i_dts )
  156.             {
  157.                 i_dts = p_buf->i_dts;
  158.                 i_stream = i;
  159.             }
  160.         }
  161.         else return -1;
  163.     }
  164.     if( pi_stream ) *pi_stream = i_stream;
  165.     if( pi_dts ) *pi_dts = i_dts;
  166.     return i_stream;
  167. }
  169. /*****************************************************************************
  170.  * Definitions of structures and functions used by this plugins 
  171.  *****************************************************************************/
  172. typedef struct
  173. {
  174.     int i_cat;
  175.     int i_fourcc;
  177.     int b_new;
  179.     mtime_t i_dts;
  180.     mtime_t i_length;
  181.     int     i_packet_no;
  182.     int     i_serial_no;
  183.     int     i_keyframe_granule_shift; /* Theora only */
  184.     ogg_stream_state os;
  186.     oggds_header_t *p_oggds_header;
  188. } ogg_stream_t;
  190. struct sout_mux_sys_t
  191. {
  192.     int     i_streams;
  194.     mtime_t i_start_dts;
  195.     int     i_next_serial_no;
  197.     /* number of logical streams pending to be added */
  198.     int i_add_streams;
  200.     /* logical streams pending to be deleted */
  201.     int i_del_streams;
  202.     ogg_stream_t **pp_del_streams;
  203. };
  205. static void OggSetDate( block_t *, mtime_t , mtime_t  );
  206. static block_t *OggStreamFlush( sout_mux_t *, ogg_stream_state *, mtime_t );
  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;
  216.     msg_Info( p_mux, "Open" );
  218.     p_sys                 = malloc( sizeof( sout_mux_sys_t ) );
  219.     p_sys->i_streams      = 0;
  220.     p_sys->i_add_streams  = 0;
  221.     p_sys->i_del_streams  = 0;
  222.     p_sys->pp_del_streams = 0;
  224.     p_mux->p_sys        = p_sys;
  225.     p_mux->pf_control   = Control;
  226.     p_mux->pf_addstream = AddStream;
  227.     p_mux->pf_delstream = DelStream;
  228.     p_mux->pf_mux       = Mux;
  230.     /* First serial number is random.
  231.      * (Done like this because on win32 you need to seed the random number
  232.      *  generator once per thread). */
  233.     srand( (unsigned int)time( NULL ) );
  234.     p_sys->i_next_serial_no = rand();
  236.     return VLC_SUCCESS;
  237. }
  239. /*****************************************************************************
  240.  * Close: Finalize ogg bitstream and close muxer
  241.  *****************************************************************************/
  242. static void Close( vlc_object_t * p_this )
  243. {
  244.     sout_mux_t     *p_mux = (sout_mux_t*)p_this;
  245.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  247.     msg_Info( p_mux, "Close" );
  249.     if( p_sys->i_del_streams )
  250.     {
  251.         block_t *p_og = NULL;
  252.         mtime_t i_dts = -1;
  253.         int i;
  255.         /* Close the current ogg stream */
  256.         msg_Dbg( p_mux, "writing footer" );
  257.         block_ChainAppend( &p_og, OggCreateFooter( p_mux, 0 ) );
  259.         /* Remove deleted logical streams */
  260.         for( i = 0; i < p_sys->i_del_streams; i++ )
  261.         {
  262.             i_dts = p_sys->pp_del_streams[i]->i_dts;
  263.             ogg_stream_clear( &p_sys->pp_del_streams[i]->os );
  264.             FREE( p_sys->pp_del_streams[i]->p_oggds_header );
  265.             FREE( p_sys->pp_del_streams[i] );
  266.         }
  267.         FREE( p_sys->pp_del_streams );
  268.         p_sys->i_streams -= p_sys->i_del_streams;
  270.         /* Write footer */
  271.         OggSetDate( p_og, i_dts, 0 );
  272.         sout_AccessOutWrite( p_mux->p_access, p_og );
  273.     }
  275.     free( p_sys );
  276. }
  278. /*****************************************************************************
  279.  * Control:
  280.  *****************************************************************************/
  281. static int Control( sout_mux_t *p_mux, int i_query, va_list args )
  282. {
  283.     vlc_bool_t *pb_bool;
  284.     char **ppsz;
  286.    switch( i_query )
  287.    {
  288.        case MUX_CAN_ADD_STREAM_WHILE_MUXING:
  289.            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
  290.            *pb_bool = VLC_TRUE;
  291.            return VLC_SUCCESS;
  293.        case MUX_GET_ADD_STREAM_WAIT:
  294.            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
  295.            *pb_bool = VLC_TRUE;
  296.            return VLC_SUCCESS;
  298.        case MUX_GET_MIME:
  299.            ppsz = (char**)va_arg( args, char ** );
  300.            *ppsz = strdup( "application/ogg" );
  301.            return VLC_SUCCESS;
  303.         default:
  304.             return VLC_EGENERIC;
  305.    }
  306. }
  307. /*****************************************************************************
  308.  * AddStream: Add an elementary stream to the muxed stream
  309.  *****************************************************************************/
  310. static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
  311. {
  312.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  313.     ogg_stream_t   *p_stream;
  314.     uint16_t i_tag;
  316.     msg_Dbg( p_mux, "adding input" );
  318.     p_input->p_sys = p_stream = malloc( sizeof( ogg_stream_t ) );
  320.     p_stream->i_cat       = p_input->p_fmt->i_cat;
  321.     p_stream->i_fourcc    = p_input->p_fmt->i_codec;
  322.     p_stream->i_serial_no = p_sys->i_next_serial_no++;
  323.     p_stream->i_packet_no = 0;
  325.     p_stream->p_oggds_header = 0;
  327.     switch( p_input->p_fmt->i_cat )
  328.     {
  329.     case VIDEO_ES:
  330.         if( !p_input->p_fmt->video.i_frame_rate ||
  331.             !p_input->p_fmt->video.i_frame_rate_base )
  332.         {
  333.             msg_Warn( p_mux, "Missing frame rate, assuming 25fps" );
  334.             p_input->p_fmt->video.i_frame_rate = 25;
  335.             p_input->p_fmt->video.i_frame_rate_base = 1;
  336.         }
  338.         switch( p_stream->i_fourcc )
  339.         {
  340.         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
  341.         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
  342.         case VLC_FOURCC( 'D', 'I', 'V', '3' ):
  343.         case VLC_FOURCC( 'M', 'J', 'P', 'G' ):
  344.         case VLC_FOURCC( 'W', 'M', 'V', '1' ):
  345.         case VLC_FOURCC( 'W', 'M', 'V', '2' ):
  346.         case VLC_FOURCC( 'W', 'M', 'V', '3' ):
  347.         case VLC_FOURCC( 'S', 'N', 'O', 'W' ):
  348.             p_stream->p_oggds_header = malloc( sizeof(oggds_header_t) );
  349.             memset( p_stream->p_oggds_header, 0, sizeof(oggds_header_t) );
  350.             p_stream->p_oggds_header->i_packet_type = PACKET_TYPE_HEADER;
  352.             memcpy( p_stream->p_oggds_header->stream_type, "video", 5 );
  353.             if( p_stream->i_fourcc == VLC_FOURCC( 'm', 'p', '4', 'v' ) )
  354.             {
  355.                 memcpy( p_stream->p_oggds_header->sub_type, "XVID", 4 );
  356.             }
  357.             else if( p_stream->i_fourcc == VLC_FOURCC( 'D', 'I', 'V', '3' ) )
  358.             {
  359.                 memcpy( p_stream->p_oggds_header->sub_type, "DIV3", 4 );
  360.             }
  361.             else
  362.             {
  363.                 memcpy( p_stream->p_oggds_header->sub_type,
  364.                         &p_stream->i_fourcc, 4 );
  365.             }
  366.             SetDWLE( &p_stream->p_oggds_header->i_size,
  367.                      sizeof( oggds_header_t ) - 1 );
  368.             SetQWLE( &p_stream->p_oggds_header->i_time_unit,
  369.                      I64C(10000000) * p_input->p_fmt->video.i_frame_rate_base /
  370.                      (int64_t)p_input->p_fmt->video.i_frame_rate );
  371.             SetQWLE( &p_stream->p_oggds_header->i_samples_per_unit, 1 );
  372.             SetDWLE( &p_stream->p_oggds_header->i_default_len, 1 ); /* ??? */
  373.             SetDWLE( &p_stream->p_oggds_header->i_buffer_size, 1024*1024 );
  374.             SetWLE( &p_stream->p_oggds_header->i_bits_per_sample, 0 );
  375.             SetDWLE( &p_stream->p_oggds_header->header.video.i_width,
  376.                      p_input->p_fmt->video.i_width );
  377.             SetDWLE( &p_stream->p_oggds_header->header.video.i_height,
  378.                      p_input->p_fmt->video.i_height );
  379.             msg_Dbg( p_mux, "%4.4s stream", (char *)&p_stream->i_fourcc );
  380.             break;
  382.         case VLC_FOURCC( 't', 'h', 'e', 'o' ):
  383.             msg_Dbg( p_mux, "theora stream" );
  384.             break;
  386.         default:
  387.             FREE( p_input->p_sys );
  388.             return VLC_EGENERIC;
  389.         }
  390.         break;
  392.     case AUDIO_ES:
  393.         switch( p_stream->i_fourcc )
  394.         {
  395.         case VLC_FOURCC( 'v', 'o', 'r', 'b' ):
  396.             msg_Dbg( p_mux, "vorbis stream" );
  397.             break;
  399.         case VLC_FOURCC( 's', 'p', 'x', ' ' ):
  400.             msg_Dbg( p_mux, "speex stream" );
  401.             break;
  403.         case VLC_FOURCC( 'f', 'l', 'a', 'c' ):
  404.             msg_Dbg( p_mux, "flac stream" );
  405.             break;
  407.         default:
  408.             fourcc_to_wf_tag( p_stream->i_fourcc, &i_tag );
  409.             if( i_tag == WAVE_FORMAT_UNKNOWN )
  410.             {
  411.                 FREE( p_input->p_sys );
  412.                 return VLC_EGENERIC;
  413.             }
  415.             p_stream->p_oggds_header =
  416.                 malloc( sizeof(oggds_header_t) + p_input->p_fmt->i_extra );
  417.             memset( p_stream->p_oggds_header, 0, sizeof(oggds_header_t) );
  418.             p_stream->p_oggds_header->i_packet_type = PACKET_TYPE_HEADER;
  420.             SetDWLE( &p_stream->p_oggds_header->i_size,
  421.                      sizeof( oggds_header_t ) - 1 + p_input->p_fmt->i_extra );
  423.             if( p_input->p_fmt->i_extra )
  424.             {
  425.                 memcpy( &p_stream->p_oggds_header[1],
  426.                         p_input->p_fmt->p_extra, p_input->p_fmt->i_extra );
  427.             }
  429.             memcpy( p_stream->p_oggds_header->stream_type, "audio", 5 );
  431.             memset( p_stream->p_oggds_header->sub_type, 0, 4 );
  432.             sprintf( p_stream->p_oggds_header->sub_type, "%-x", i_tag );
  434.             SetQWLE( &p_stream->p_oggds_header->i_time_unit, I64C(10000000) );
  435.             SetDWLE( &p_stream->p_oggds_header->i_default_len, 1 );
  436.             SetDWLE( &p_stream->p_oggds_header->i_buffer_size, 30*1024 );
  437.             SetQWLE( &p_stream->p_oggds_header->i_samples_per_unit,
  438.                      p_input->p_fmt->audio.i_rate );
  439.             SetWLE( &p_stream->p_oggds_header->i_bits_per_sample,
  440.                     p_input->p_fmt->audio.i_bitspersample );
  441.             SetDWLE( &p_stream->p_oggds_header->header.audio.i_channels,
  442.                      p_input->p_fmt->audio.i_channels );
  443.             SetDWLE( &p_stream->p_oggds_header->header.audio.i_block_align,
  444.                      p_input->p_fmt->audio.i_blockalign );
  445.             SetDWLE( &p_stream->p_oggds_header->header.audio.i_avgbytespersec,
  446.                      p_input->p_fmt->i_bitrate / 8);
  447.             msg_Dbg( p_mux, "%4.4s stream", (char *)&p_stream->i_fourcc );
  448.             break;
  449.         }
  450.         break;
  452.     case SPU_ES:
  453.         switch( p_stream->i_fourcc )
  454.         {
  455.         case VLC_FOURCC( 's', 'u','b', 't' ):
  456.             p_stream->p_oggds_header = malloc( sizeof(oggds_header_t) );
  457.             memset( p_stream->p_oggds_header, 0, sizeof(oggds_header_t) );
  458.             p_stream->p_oggds_header->i_packet_type = PACKET_TYPE_HEADER;
  460.             memcpy( p_stream->p_oggds_header->stream_type, "text", 4 );
  461.             msg_Dbg( p_mux, "subtitles stream" );
  462.             break;
  464.         default:
  465.             FREE( p_input->p_sys );
  466.             return VLC_EGENERIC;
  467.         }
  468.         break;
  469.     default:
  470.         FREE( p_input->p_sys );
  471.         return VLC_EGENERIC;
  472.     }
  474.     p_stream->b_new = VLC_TRUE;
  476.     p_sys->i_add_streams++;
  478.     return VLC_SUCCESS;
  479. }
  481. /*****************************************************************************
  482.  * DelStream: Delete an elementary stream from the muxed stream
  483.  *****************************************************************************/
  484. static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
  485. {
  486.     sout_mux_sys_t *p_sys  = p_mux->p_sys;
  487.     ogg_stream_t   *p_stream = (ogg_stream_t*)p_input->p_sys;
  488.     block_t *p_og;
  490.     msg_Dbg( p_mux, "removing input" );
  492.     /* flush all remaining data */
  493.     if( p_input->p_sys )
  494.     {
  495.         if( !p_stream->b_new )
  496.         {
  497.             while( p_input->p_fifo->i_depth ) MuxBlock( p_mux, p_input );
  498.         }
  500.         if( !p_stream->b_new &&
  501.             ( p_og = OggStreamFlush( p_mux, &p_stream->os, 0 ) ) )
  502.         {
  503.             OggSetDate( p_og, p_stream->i_dts, p_stream->i_length );
  504.             sout_AccessOutWrite( p_mux->p_access, p_og );
  505.         }
  507.         /* move input in delete queue */
  508.         if( !p_stream->b_new )
  509.         {
  510.             p_sys->pp_del_streams = realloc( p_sys->pp_del_streams,
  511.                                              (p_sys->i_del_streams + 1) *
  512.                                              sizeof(ogg_stream_t *) );
  513.             p_sys->pp_del_streams[p_sys->i_del_streams++] = p_stream;
  514.         }
  515.         else
  516.         {
  517.             /* Wasn't already added so get rid of it */
  518.             FREE( p_stream->p_oggds_header );
  519.             FREE( p_stream );
  520.             p_sys->i_add_streams--;
  521.         }
  522.     }
  524.     p_input->p_sys = NULL;
  526.     return 0;
  527. }
  529. /*****************************************************************************
  530.  * Ogg bitstream manipulation routines
  531.  *****************************************************************************/
  532. static block_t *OggStreamFlush( sout_mux_t *p_mux,
  533.                                 ogg_stream_state *p_os, mtime_t i_pts )
  534. {
  535.     block_t *p_og, *p_og_first = NULL;
  536.     ogg_page og;
  538.     while( ogg_stream_flush( p_os, &og ) )
  539.     {
  540.         /* Flush all data */
  541.         p_og = block_New( p_mux, og.header_len + og.body_len );
  543.         memcpy( p_og->p_buffer, og.header, og.header_len );
  544.         memcpy( p_og->p_buffer + og.header_len, og.body, og.body_len );
  545.         p_og->i_dts     = 0;
  546.         p_og->i_pts     = i_pts;
  547.         p_og->i_length  = 0;
  549.         i_pts = 0; // write it only once
  551.         block_ChainAppend( &p_og_first, p_og );
  552.     }
  554.     return p_og_first;
  555. }
  557. static block_t *OggStreamPageOut( sout_mux_t *p_mux,
  558.                                   ogg_stream_state *p_os, mtime_t i_pts )
  559. {
  560.     block_t *p_og, *p_og_first = NULL;
  561.     ogg_page og;
  563.     while( ogg_stream_pageout( p_os, &og ) )
  564.     {
  565.         /* Flush all data */
  566.         p_og = block_New( p_mux, og.header_len + og.body_len );
  568.         memcpy( p_og->p_buffer, og.header, og.header_len );
  569.         memcpy( p_og->p_buffer + og.header_len, og.body, og.body_len );
  570.         p_og->i_dts     = 0;
  571.         p_og->i_pts     = i_pts;
  572.         p_og->i_length  = 0;
  574.         i_pts = 0; // write them only once
  576.         block_ChainAppend( &p_og_first, p_og );
  577.     }
  579.     return p_og_first;
  580. }
  582. static block_t *OggCreateHeader( sout_mux_t *p_mux, mtime_t i_dts )
  583. {
  584.     block_t *p_hdr = NULL;
  585.     block_t *p_og = NULL;
  586.     ogg_packet op;
  587.     uint8_t *p_extra;
  588.     int i, i_extra;
  590.     /* Write header for each stream. All b_o_s (beginning of stream) packets
  591.      * must appear first in the ogg stream so we take care of them first. */
  592.     for( i = 0; i < p_mux->i_nb_inputs; i++ )
  593.     {
  594.         sout_input_t *p_input = p_mux->pp_inputs[i];
  595.         ogg_stream_t *p_stream = (ogg_stream_t*)p_input->p_sys;
  596.         p_stream->b_new = VLC_FALSE;
  598.         msg_Dbg( p_mux, "creating header for %4.4s",
  599.                  (char *)&p_stream->i_fourcc );
  601.         ogg_stream_init( &p_stream->os, p_stream->i_serial_no );
  602.         p_stream->i_packet_no = 0;
  604.         if( p_stream->i_fourcc == VLC_FOURCC( 'v', 'o', 'r', 'b' ) ||
  605.             p_stream->i_fourcc == VLC_FOURCC( 's', 'p', 'x', ' ' ) ||
  606.             p_stream->i_fourcc == VLC_FOURCC( 't', 'h', 'e', 'o' ) )
  607.         {
  608.             /* First packet in order: vorbis/speex/theora info */
  609.             p_extra = p_input->p_fmt->p_extra;
  610.             i_extra = p_input->p_fmt->i_extra;
  612.             op.bytes = *(p_extra++) << 8;
  613.             op.bytes |= (*(p_extra++) & 0xFF);
  614.             op.packet = p_extra;
  615.             i_extra -= (op.bytes + 2);
  616.             if( i_extra < 0 )
  617.             {
  618.                 msg_Err( p_mux, "header data corrupted");
  619.                 op.bytes += i_extra;
  620.             }
  622.             op.b_o_s  = 1;
  623.             op.e_o_s  = 0;
  624.             op.granulepos = 0;
  625.             op.packetno = p_stream->i_packet_no++;
  626.             ogg_stream_packetin( &p_stream->os, &op );
  627.             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  629.             /* Get keyframe_granule_shift for theora granulepos calculation */
  630.             if( p_stream->i_fourcc == VLC_FOURCC( 't', 'h', 'e', 'o' ) )
  631.             {
  632.                 int i_keyframe_frequency_force =
  633.                       1 << ((op.packet[40] << 6 >> 3) | (op.packet[41] >> 5));
  635.                 /* granule_shift = i_log( frequency_force -1 ) */
  636.                 p_stream->i_keyframe_granule_shift = 0;
  637.                 i_keyframe_frequency_force--;
  638.                 while( i_keyframe_frequency_force )
  639.                 {
  640.                     p_stream->i_keyframe_granule_shift++;
  641.                     i_keyframe_frequency_force >>= 1;
  642.                 }
  643.             }
  644.         }
  645.         else if( p_stream->i_fourcc == VLC_FOURCC( 'f', 'l', 'a', 'c' ) )
  646.         {
  647.             /* flac stream marker (yeah, only that in the 1st packet) */
  648.             op.packet = "fLaC";
  649.             op.bytes  = 4;
  650.             op.b_o_s  = 1;
  651.             op.e_o_s  = 0;
  652.             op.granulepos = 0;
  653.             op.packetno = p_stream->i_packet_no++;
  654.             ogg_stream_packetin( &p_stream->os, &op );
  655.             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  656.         }
  657.         else if( p_stream->p_oggds_header )
  658.         {
  659.             /* ds header */
  660.             op.packet = (uint8_t*)p_stream->p_oggds_header;
  661.             op.bytes  = p_stream->p_oggds_header->i_size + 1;
  662.             op.b_o_s  = 1;
  663.             op.e_o_s  = 0;
  664.             op.granulepos = 0;
  665.             op.packetno = p_stream->i_packet_no++;
  666.             ogg_stream_packetin( &p_stream->os, &op );
  667.             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  668.         }
  670.         block_ChainAppend( &p_hdr, p_og );
  671.     }
  673.     /* Take care of the non b_o_s headers */
  674.     for( i = 0; i < p_mux->i_nb_inputs; i++ )
  675.     {
  676.         sout_input_t *p_input = p_mux->pp_inputs[i];
  677.         ogg_stream_t *p_stream = (ogg_stream_t*)p_input->p_sys;
  679.         if( p_stream->i_fourcc == VLC_FOURCC( 'v', 'o', 'r', 'b' ) ||
  680.             p_stream->i_fourcc == VLC_FOURCC( 's', 'p', 'x', ' ' ) ||
  681.             p_stream->i_fourcc == VLC_FOURCC( 't', 'h', 'e', 'o' ) )
  682.         {
  683.             /* Special case, headers are already there in the incoming stream.
  684.              * We need to gather them an mark them as headers. */
  685.             int j = 2;
  687.             if( p_stream->i_fourcc == VLC_FOURCC( 's', 'p', 'x', ' ' ) ) j = 1;
  689.             p_extra = p_input->p_fmt->p_extra;
  690.             i_extra = p_input->p_fmt->i_extra;
  692.             /* Skip 1 header */
  693.             op.bytes = *(p_extra++) << 8;
  694.             op.bytes |= (*(p_extra++) & 0xFF);
  695.             op.packet = p_extra;
  696.             p_extra += op.bytes;
  697.             i_extra -= (op.bytes + 2);
  699.             while( j-- )
  700.             {
  701.                 op.bytes = *(p_extra++) << 8;
  702.                 op.bytes |= (*(p_extra++) & 0xFF);
  703.                 op.packet = p_extra;
  704.                 p_extra += op.bytes;
  705.                 i_extra -= (op.bytes + 2);
  706.                 if( i_extra < 0 )
  707.                 {
  708.                     msg_Err( p_mux, "header data corrupted");
  709.                     op.bytes += i_extra;
  710.                 }
  712.                 op.b_o_s  = 0;
  713.                 op.e_o_s  = 0;
  714.                 op.granulepos = 0;
  715.                 op.packetno = p_stream->i_packet_no++;
  716.                 ogg_stream_packetin( &p_stream->os, &op );
  718.                 p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  719.                 block_ChainAppend( &p_hdr, p_og );
  720.             }
  721.         }
  722.         else if( p_stream->i_fourcc != VLC_FOURCC( 'f', 'l', 'a', 'c' ) )
  723.         {
  724.             uint8_t com[128];
  725.             int     i_com;
  727.             /* comment */
  728.             com[0] = PACKET_TYPE_COMMENT;
  729.             i_com = snprintf( &com[1], 128, PACKAGE_VERSION" stream output" )
  730.                      + 1;
  731.             op.packet = com;
  732.             op.bytes  = i_com;
  733.             op.b_o_s  = 0;
  734.             op.e_o_s  = 0;
  735.             op.granulepos = 0;
  736.             op.packetno = p_stream->i_packet_no++;
  737.             ogg_stream_packetin( &p_stream->os, &op );
  738.             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  739.             block_ChainAppend( &p_hdr, p_og );
  740.         }
  742.         /* Special case for mp4v and flac */
  743.         if( ( p_stream->i_fourcc == VLC_FOURCC( 'm', 'p', '4', 'v' ) ||
  744.               p_stream->i_fourcc == VLC_FOURCC( 'f', 'l', 'a', 'c' ) ) &&
  745.             p_input->p_fmt->i_extra )
  746.         {
  747.             /* Send a packet with the VOL data for mp4v
  748.              * or STREAMINFO for flac */
  749.             msg_Dbg( p_mux, "writing extra data" );
  750.             op.bytes  = p_input->p_fmt->i_extra;
  751.             op.packet = p_input->p_fmt->p_extra;
  752.             if( p_stream->i_fourcc == VLC_FOURCC( 'f', 'l', 'a', 'c' ) )
  753.             {
  754.                 /* Skip the flac stream marker */
  755.                 op.bytes -= 4;
  756.                 op.packet+= 4;
  757.             }
  758.             op.b_o_s  = 0;
  759.             op.e_o_s  = 0;
  760.             op.granulepos = 0;
  761.             op.packetno = p_stream->i_packet_no++;
  762.             ogg_stream_packetin( &p_stream->os, &op );
  763.             p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  764.             block_ChainAppend( &p_hdr, p_og );
  765.         }
  766.     }
  768.     /* set HEADER flag */
  769.     for( p_og = p_hdr; p_og != NULL; p_og = p_og->p_next )
  770.     {
  771.         p_og->i_flags |= BLOCK_FLAG_HEADER;
  772.     }
  773.     return p_hdr;
  774. }
  776. static block_t *OggCreateFooter( sout_mux_t *p_mux, mtime_t i_dts )
  777. {
  778.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  779.     block_t *p_hdr = NULL;
  780.     block_t *p_og;
  781.     ogg_packet    op;
  782.     int i;
  784.     /* flush all remaining data */
  785.     for( i = 0; i < p_mux->i_nb_inputs; i++ )
  786.     {
  787.         ogg_stream_t *p_stream = p_mux->pp_inputs[i]->p_sys;
  789.         /* skip newly added streams */
  790.         if( p_stream->b_new ) continue;
  792.         if( ( p_og = OggStreamFlush( p_mux, &p_stream->os, 0 ) ) )
  793.         {
  794.             OggSetDate( p_og, p_stream->i_dts, p_stream->i_length );
  795.             sout_AccessOutWrite( p_mux->p_access, p_og );
  796.         }
  797.     }
  799.     /* Write eos packets for each stream. */
  800.     for( i = 0; i < p_mux->i_nb_inputs; i++ )
  801.     {
  802.         ogg_stream_t *p_stream = p_mux->pp_inputs[i]->p_sys;
  804.         /* skip newly added streams */
  805.         if( p_stream->b_new ) continue;
  807.         op.packet = NULL;
  808.         op.bytes  = 0;
  809.         op.b_o_s  = 0;
  810.         op.e_o_s  = 1;
  811.         op.granulepos = -1;
  812.         op.packetno = p_stream->i_packet_no++;
  813.         ogg_stream_packetin( &p_stream->os, &op );
  815.         p_og = OggStreamFlush( p_mux, &p_stream->os, 0 );
  816.         block_ChainAppend( &p_hdr, p_og );
  817.         ogg_stream_clear( &p_stream->os );
  818.     }
  820.     for( i = 0; i < p_sys->i_del_streams; i++ )
  821.     {
  822.         op.packet = NULL;
  823.         op.bytes  = 0;
  824.         op.b_o_s  = 0;
  825.         op.e_o_s  = 1;
  826.         op.granulepos = -1;
  827.         op.packetno = p_sys->pp_del_streams[i]->i_packet_no++;
  828.         ogg_stream_packetin( &p_sys->pp_del_streams[i]->os, &op );
  830.         p_og = OggStreamFlush( p_mux, &p_sys->pp_del_streams[i]->os, 0 );
  831.         block_ChainAppend( &p_hdr, p_og );
  832.         ogg_stream_clear( &p_sys->pp_del_streams[i]->os );
  833.     }
  835.     return p_hdr;
  836. }
  838. static void OggSetDate( block_t *p_og, mtime_t i_dts, mtime_t i_length )
  839. {
  840.     int i_count;
  841.     block_t *p_tmp;
  842.     mtime_t i_delta;
  844.     for( p_tmp = p_og, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->p_next )
  845.     {
  846.         i_count++;
  847.     }
  848.     i_delta = i_length / i_count;
  850.     for( p_tmp = p_og; p_tmp != NULL; p_tmp = p_tmp->p_next )
  851.     {
  852.         p_tmp->i_dts    = i_dts;
  853.         p_tmp->i_length = i_delta;
  855.         i_dts += i_delta;
  856.     }
  857. }
  859. /*****************************************************************************
  860.  * Mux: multiplex available data in input fifos into the Ogg bitstream
  861.  *****************************************************************************/
  862. static int Mux( sout_mux_t *p_mux )
  863. {
  864.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  865.     block_t        *p_og = NULL;
  866.     int            i_stream;
  867.     mtime_t        i_dts;
  869.     if( p_sys->i_add_streams || p_sys->i_del_streams )
  870.     {
  871.         /* Open new ogg stream */
  872.         if( MuxGetStream( p_mux, &i_stream, &i_dts) < 0 )
  873.         {
  874.             msg_Dbg( p_mux, "waiting for data..." );
  875.             return VLC_SUCCESS;
  876.         }
  878.         if( p_sys->i_streams )
  879.         {
  880.             /* Close current ogg stream */
  881.             int i;
  883.             msg_Dbg( p_mux, "writing footer" );
  884.             block_ChainAppend( &p_og, OggCreateFooter( p_mux, 0 ) );
  886.             /* Remove deleted logical streams */
  887.             for( i = 0; i < p_sys->i_del_streams; i++ )
  888.             {
  889.                 FREE( p_sys->pp_del_streams[i]->p_oggds_header );
  890.                 FREE( p_sys->pp_del_streams[i] );
  891.             }
  892.             FREE( p_sys->pp_del_streams );
  893.             p_sys->i_streams = 0;
  894.         }
  896.         msg_Dbg( p_mux, "writing header" );
  897.         p_sys->i_start_dts = i_dts;
  898.         p_sys->i_streams = p_mux->i_nb_inputs;
  899.         p_sys->i_del_streams = 0;
  900.         p_sys->i_add_streams = 0;
  901.         block_ChainAppend( &p_og, OggCreateHeader( p_mux, i_dts ) );
  903.         /* Write header and/or footer */
  904.         OggSetDate( p_og, i_dts, 0 );
  905.         sout_AccessOutWrite( p_mux->p_access, p_og );
  906.         p_og = NULL;
  907.     }
  909.     for( ;; )
  910.     {
  911.         if( MuxGetStream( p_mux, &i_stream, 0 ) < 0 ) return VLC_SUCCESS;
  912.         MuxBlock( p_mux, p_mux->pp_inputs[i_stream] );
  913.     }
  915.     return VLC_SUCCESS;
  916. }
  918. static int MuxBlock( sout_mux_t *p_mux, sout_input_t *p_input )
  919. {
  920.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  921.     ogg_stream_t *p_stream = (ogg_stream_t*)p_input->p_sys;
  922.     block_t *p_data = block_FifoGet( p_input->p_fifo );
  923.     block_t *p_og = NULL;
  924.     ogg_packet op;
  926.     if( p_stream->i_fourcc != VLC_FOURCC( 'v', 'o', 'r', 'b' ) &&
  927.         p_stream->i_fourcc != VLC_FOURCC( 'f', 'l', 'a', 'c' ) &&
  928.         p_stream->i_fourcc != VLC_FOURCC( 's', 'p', 'x', ' ' ) &&
  929.         p_stream->i_fourcc != VLC_FOURCC( 't', 'h', 'e', 'o' ) )
  930.     {
  931.         p_data = block_Realloc( p_data, 1, p_data->i_buffer );
  932.         p_data->p_buffer[0] = PACKET_IS_SYNCPOINT;      // FIXME
  933.     }
  935.     op.packet   = p_data->p_buffer;
  936.     op.bytes    = p_data->i_buffer;
  937.     op.b_o_s    = 0;
  938.     op.e_o_s    = 0;
  939.     op.packetno = p_stream->i_packet_no++;
  941.     if( p_stream->i_cat == AUDIO_ES )
  942.     {
  943.         if( p_stream->i_fourcc == VLC_FOURCC( 'v', 'o', 'r', 'b' ) ||
  944.             p_stream->i_fourcc == VLC_FOURCC( 'f', 'l', 'a', 'c' ) ||
  945.             p_stream->i_fourcc == VLC_FOURCC( 's', 'p', 'x', ' ' ) )
  946.         {
  947.             /* number of sample from begining + current packet */
  948.             op.granulepos =
  949.                 ( p_data->i_dts - p_sys->i_start_dts + p_data->i_length ) *
  950.                 (mtime_t)p_input->p_fmt->audio.i_rate / I64C(1000000);
  951.         }
  952.         else if( p_stream->p_oggds_header )
  953.         {
  954.             /* number of sample from begining */
  955.             op.granulepos = ( p_data->i_dts - p_sys->i_start_dts ) *
  956.                 p_stream->p_oggds_header->i_samples_per_unit / I64C(1000000);
  957.         }
  958.     }
  959.     else if( p_stream->i_cat == VIDEO_ES )
  960.     {
  961.         if( p_stream->i_fourcc == VLC_FOURCC( 't', 'h', 'e', 'o' ) )
  962.         {
  963.             /* FIXME, we assume only keyframes */
  964.             op.granulepos = ( ( p_data->i_dts - p_sys->i_start_dts ) *
  965.                 p_input->p_fmt->video.i_frame_rate /
  966.                 p_input->p_fmt->video.i_frame_rate_base /
  967.                 I64C(1000000) ) << p_stream->i_keyframe_granule_shift;
  968.         }
  969.         else if( p_stream->p_oggds_header )
  970.             op.granulepos = ( p_data->i_dts - p_sys->i_start_dts ) * I64C(10) /
  971.                 p_stream->p_oggds_header->i_time_unit;
  972.     }
  973.     else if( p_stream->i_cat == SPU_ES )
  974.     {
  975.         /* granulepos is in milisec */
  976.         op.granulepos = ( p_data->i_dts - p_sys->i_start_dts ) / 1000;
  977.     }
  979.     ogg_stream_packetin( &p_stream->os, &op );
  981.     if( p_stream->i_cat == SPU_ES ||
  982.         p_stream->i_fourcc == VLC_FOURCC( 's', 'p', 'x', ' ' ) )
  983.     {
  984.         /* Subtitles or Speex packets are quite small so they 
  985.          * need to be flushed to be sent on time */
  986.         p_og = OggStreamFlush( p_mux, &p_stream->os, p_data->i_dts );
  987.     }
  988.     else
  989.     {
  990.         p_og = OggStreamPageOut( p_mux, &p_stream->os, p_data->i_dts );
  991.     }
  993.     if( p_og )
  994.     {
  995.         OggSetDate( p_og, p_stream->i_dts, p_stream->i_length );
  996.         p_stream->i_dts = -1;
  997.         p_stream->i_length = 0;
  999.         sout_AccessOutWrite( p_mux->p_access, p_og );
  1000.     }
  1001.     else
  1002.     {
  1003.         if( p_stream->i_dts < 0 )
  1004.         {
  1005.             p_stream->i_dts = p_data->i_dts;
  1006.         }
  1007.         p_stream->i_length += p_data->i_length;
  1008.     }
  1010.     block_Release( p_data );
  1011.     return VLC_SUCCESS;
  1012. }