1 /* $Id: muxogm.c,v 1.4 2005/02/20 00:41:56 titer Exp $
3 This file is part of the HandBrake source code.
4 Homepage: <http://handbrake.fr/>.
5 It may be used under the terms of the GNU General Public License. */
11 struct hb_mux_object_s
27 typedef struct __attribute__((__packed__))
29 uint8_t i_packet_type;
37 int64_t i_samples_per_unit;
38 int32_t i_default_len;
40 int32_t i_buffer_size;
41 int16_t i_bits_per_sample;
42 int16_t i_padding_0; // hum hum
54 int16_t i_block_align;
55 int32_t i_avgbytespersec;
59 } ogg_stream_header_t;
61 #define SetWLE( p, v ) _SetWLE( (uint8_t*)p, v)
62 static void _SetWLE( uint8_t *p, uint16_t i_dw )
64 p[1] = ( i_dw >> 8 )&0xff;
68 #define SetDWLE( p, v ) _SetDWLE( (uint8_t*)p, v)
69 static void _SetDWLE( uint8_t *p, uint32_t i_dw )
71 p[3] = ( i_dw >> 24 )&0xff;
72 p[2] = ( i_dw >> 16 )&0xff;
73 p[1] = ( i_dw >> 8 )&0xff;
76 #define SetQWLE( p, v ) _SetQWLE( (uint8_t*)p, v)
77 static void _SetQWLE( uint8_t *p, uint64_t i_qw )
79 SetDWLE( p, i_qw&0xffffffff );
80 SetDWLE( p+4, ( i_qw >> 32)&0xffffffff );
83 static int OGMFlush( hb_mux_object_t * m, hb_mux_data_t * mux_data )
88 if( ogg_stream_flush( &mux_data->os, &og ) == 0 )
92 if( fwrite( og.header, og.header_len, 1, m->file ) <= 0 ||
93 fwrite( og.body, og.body_len, 1, m->file ) <= 0 )
101 /**********************************************************************
103 **********************************************************************
104 * Allocates hb_mux_data_t structures, create file and write headers
105 *********************************************************************/
106 static int OGMInit( hb_mux_object_t * m )
108 hb_job_t * job = m->job;
109 hb_title_t * title = job->title;
112 hb_mux_data_t * mux_data;
116 ogg_stream_header_t h;
118 /* Open output file */
119 if( ( m->file = fopen( job->file, "wb" ) ) == NULL )
121 hb_log( "muxogm: failed to open `%s'", job->file );
124 hb_log( "muxogm: `%s' opened", job->file );
127 mux_data = malloc( sizeof( hb_mux_data_t ) );
128 mux_data->codec = job->vcodec;
129 mux_data->i_packet_no = 0;
130 job->mux_data = mux_data;
131 ogg_stream_init( &mux_data->os, 0 );
134 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
136 audio = hb_list_item( title->list_audio, i );
137 mux_data = malloc( sizeof( hb_mux_data_t ) );
138 mux_data->codec = audio->config.out.codec;
139 mux_data->i_packet_no = 0;
140 audio->priv.mux_data = mux_data;
141 ogg_stream_init( &mux_data->os, i + 1 );
145 /* First pass: all b_o_s packets */
146 hb_log("muxogm: Writing b_o_s header packets");
148 mux_data = job->mux_data;
149 switch( job->vcodec )
151 case HB_VCODEC_THEORA:
152 memcpy(&op, job->config.theora.headers[0], sizeof(op));
153 op.packet = job->config.theora.headers[0] + sizeof(op);
154 ogg_stream_packetin( &mux_data->os, &op );
157 case HB_VCODEC_FFMPEG:
159 memset( &h, 0, sizeof( ogg_stream_header_t ) );
160 h.i_packet_type = 0x01;
161 memcpy( h.stream_type, "video ", 8 );
162 if( mux_data->codec == HB_VCODEC_X264 )
164 memcpy( h.sub_type, "H264", 4 );
168 memcpy( h.sub_type, "DX50", 4 );
170 SetDWLE( &h.i_size, sizeof( ogg_stream_header_t ) - 1);
171 SetQWLE( &h.i_time_unit, (int64_t) 10 * 1000 * 1000 *
172 (int64_t) job->vrate_base / (int64_t) job->vrate );
173 SetQWLE( &h.i_samples_per_unit, 1 );
174 SetDWLE( &h.i_default_len, 0 );
175 SetDWLE( &h.i_buffer_size, 1024*1024 );
176 SetWLE ( &h.i_bits_per_sample, 0 );
177 SetDWLE( &h.header.video.i_width, job->width );
178 SetDWLE( &h.header.video.i_height, job->height );
179 op.packet = (unsigned char*)&h;
180 op.bytes = sizeof( ogg_stream_header_t );
184 op.packetno = mux_data->i_packet_no++;
185 ogg_stream_packetin( &mux_data->os, &op );
189 hb_error( "muxogm: unhandled video codec" );
192 OGMFlush( m, mux_data );
195 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
197 audio = hb_list_item( title->list_audio, i );
198 mux_data = audio->priv.mux_data;
199 memset( &h, 0, sizeof( ogg_stream_header_t ) );
200 switch( audio->config.out.codec )
204 h.i_packet_type = 0x01;
205 memcpy( h.stream_type, "audio ", 8 );
206 memcpy( h.sub_type, "55 ", 4 );
208 SetDWLE( &h.i_size, sizeof( ogg_stream_header_t ) - 1);
209 SetQWLE( &h.i_time_unit, 0 );
210 SetQWLE( &h.i_samples_per_unit, audio->config.out.samplerate );
211 SetDWLE( &h.i_default_len, 1 );
212 SetDWLE( &h.i_buffer_size, 30 * 1024 );
213 SetWLE ( &h.i_bits_per_sample, 0 );
215 SetDWLE( &h.header.audio.i_channels, 2 );
216 SetDWLE( &h.header.audio.i_block_align, 0 );
217 SetDWLE( &h.header.audio.i_avgbytespersec,
218 audio->config.out.bitrate / 8 );
220 op.packet = (unsigned char*) &h;
221 op.bytes = sizeof( ogg_stream_header_t );
225 op.packetno = mux_data->i_packet_no++;
226 ogg_stream_packetin( &mux_data->os, &op );
229 case HB_ACODEC_VORBIS:
231 memcpy( &op, audio->priv.config.vorbis.headers[0],
232 sizeof( ogg_packet ) );
233 op.packet = audio->priv.config.vorbis.headers[0] +
234 sizeof( ogg_packet );
235 ogg_stream_packetin( &mux_data->os, &op );
239 hb_log( "muxogm: unhandled codec" );
242 OGMFlush( m, mux_data );
245 /* second pass: all non b_o_s packets */
246 hb_log("muxogm: Writing non b_o_s header packets");
248 mux_data = job->mux_data;
249 switch( job->vcodec )
251 case HB_VCODEC_THEORA:
252 for (i = 1; i < 3; i++)
254 memcpy(&op, job->config.theora.headers[i], sizeof(op));
255 op.packet = job->config.theora.headers[i] + sizeof(op);
256 ogg_stream_packetin( &mux_data->os, &op );
257 OGMFlush( m, mux_data );
261 case HB_VCODEC_FFMPEG:
264 hb_error( "muxogm: unhandled video codec" );
269 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
271 audio = hb_list_item( title->list_audio, i );
272 if( audio->config.out.codec == HB_ACODEC_VORBIS )
275 mux_data = audio->priv.mux_data;
277 for( j = 1; j < 3; j++ )
279 memcpy( &op, audio->priv.config.vorbis.headers[j],
280 sizeof( ogg_packet ) );
281 op.packet = audio->priv.config.vorbis.headers[j] +
282 sizeof( ogg_packet );
283 ogg_stream_packetin( &mux_data->os, &op );
285 OGMFlush( m, mux_data );
289 hb_log( "muxogm: headers written" );
294 static int OGMMux( hb_mux_object_t * m, hb_mux_data_t * mux_data,
299 switch( mux_data->codec )
301 case HB_VCODEC_THEORA:
302 memcpy( &op, buf->data, sizeof( ogg_packet ) );
303 op.packet = malloc( op.bytes );
304 memcpy( op.packet, buf->data + sizeof( ogg_packet ), op.bytes );
306 case HB_VCODEC_FFMPEG:
308 op.bytes = buf->size + 1;
309 op.packet = malloc( op.bytes );
310 op.packet[0] = (buf->frametype & HB_FRAME_KEY) ? 0x08 : 0x00;
311 memcpy( &op.packet[1], buf->data, buf->size );
314 op.granulepos = mux_data->i_packet_no;
315 op.packetno = mux_data->i_packet_no++;
318 op.bytes = buf->size + 1;
319 op.packet = malloc( op.bytes );
321 memcpy( &op.packet[1], buf->data, buf->size );
324 op.granulepos = mux_data->i_packet_no * 1152;
325 op.packetno = mux_data->i_packet_no++;
327 case HB_ACODEC_VORBIS:
328 memcpy( &op, buf->data, sizeof( ogg_packet ) );
329 op.packet = malloc( op.bytes );
330 memcpy( op.packet, buf->data + sizeof( ogg_packet ), op.bytes );
334 hb_log( "muxogm: unhandled codec" );
342 ogg_stream_packetin( &mux_data->os, &op );
347 if( ogg_stream_pageout( &mux_data->os, &og ) == 0 )
352 if( fwrite( og.header, og.header_len, 1, m->file ) <= 0 ||
353 fwrite( og.body, og.body_len, 1, m->file ) <= 0 )
355 hb_log( "muxogm: write failed" );
364 static int OGMEnd( hb_mux_object_t * m )
366 hb_job_t * job = m->job;
368 hb_title_t * title = job->title;
370 hb_mux_data_t * mux_data;
373 mux_data = job->mux_data;
374 if( OGMFlush( m, mux_data ) < 0 )
378 ogg_stream_clear( &mux_data->os );
380 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
382 audio = hb_list_item( title->list_audio, i );
383 mux_data = audio->priv.mux_data;
384 if( OGMFlush( m, mux_data ) < 0 )
388 ogg_stream_clear( &mux_data->os );
392 hb_log( "muxogm: `%s' closed", job->file );
397 hb_mux_object_t * hb_mux_ogm_init( hb_job_t * job )
399 hb_mux_object_t * m = calloc( sizeof( hb_mux_object_t ), 1 );