8e3a6ec4c2ef35b273fb028aeb0240fa1c96b7ba
[vlc.git] / modules / packetizer / mpegvideo.c
1 /*****************************************************************************
2  * mpegvideo.c
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VideoLAN
5  * $Id: mpegvideo.c,v 1.11 2003/03/31 03:46:11 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Eric Petit <titer@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  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <vlc/vlc.h>
29 #include <vlc/decoder.h>
30 #include <vlc/input.h>
31 #include <vlc/sout.h>
32 #include "codecs.h"                         /* WAVEFORMATEX BITMAPINFOHEADER */
33
34 #include <stdlib.h>                                      /* malloc(), free() */
35 #include <string.h>                                              /* strdup() */
36
37 /*****************************************************************************
38  * Local prototypes
39  *****************************************************************************/
40 typedef struct packetizer_s
41 {
42     /* Input properties */
43     decoder_fifo_t          *p_fifo;
44     bit_stream_t            bit_stream;
45
46     /* Output properties */
47     sout_packetizer_input_t *p_sout_input;
48     sout_packet_format_t    output_format;
49
50     mtime_t                 i_last_dts;
51     mtime_t                 i_last_ref_pts;
52     double                  d_frame_rate;
53     int                     i_progressive_sequence;
54     uint8_t                 p_sequence_header[150];
55     int                     i_sequence_header_length;
56     int                     i_last_sequence_header;
57
58     int                     i_last_picture_structure;
59 } packetizer_t;
60
61 static int  Open    ( vlc_object_t * );
62 static int  Run     ( decoder_fifo_t * );
63
64 static int  InitThread     ( packetizer_t * );
65 static void PacketizeThread   ( packetizer_t * );
66 static void EndThread      ( packetizer_t * );
67
68 /*****************************************************************************
69  * Module descriptor
70  *****************************************************************************/
71
72 vlc_module_begin();
73     set_description( _("MPEG-I/II video packetizer") );
74     set_capability( "packetizer", 50 );
75     set_callbacks( Open, NULL );
76 vlc_module_end();
77
78 /*****************************************************************************
79  * OpenDecoder: probe the packetizer and return score
80  *****************************************************************************
81  * Tries to launch a decoder and return score so that the interface is able
82  * to choose.
83  *****************************************************************************/
84 static int Open( vlc_object_t *p_this )
85 {
86     decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
87
88     if( p_fifo->i_fourcc != VLC_FOURCC( 'm', 'p', 'g', 'v') &&
89         p_fifo->i_fourcc != VLC_FOURCC( 'm', 'p', 'g', '1') &&
90         p_fifo->i_fourcc != VLC_FOURCC( 'm', 'p', 'g', '2') )
91     {
92         return VLC_EGENERIC;
93     }
94
95     p_fifo->pf_run = Run;
96     return VLC_SUCCESS;
97 }
98
99 /*****************************************************************************
100  * RunDecoder: this function is called just after the thread is created
101  *****************************************************************************/
102 static int Run( decoder_fifo_t *p_fifo )
103 {
104     packetizer_t *p_pack;
105     int b_error;
106
107     msg_Info( p_fifo, "Running mpegvideo packetizer" );
108     if( !( p_pack = malloc( sizeof( packetizer_t ) ) ) )
109     {
110         msg_Err( p_fifo, "out of memory" );
111         DecoderError( p_fifo );
112         return( -1 );
113     }
114     memset( p_pack, 0, sizeof( packetizer_t ) );
115
116     p_pack->p_fifo = p_fifo;
117
118     if( InitThread( p_pack ) != 0 )
119     {
120         DecoderError( p_fifo );
121         return( -1 );
122     }
123
124     while( ( !p_pack->p_fifo->b_die )&&( !p_pack->p_fifo->b_error ) )
125     {
126         PacketizeThread( p_pack );
127     }
128
129
130     if( ( b_error = p_pack->p_fifo->b_error ) )
131     {
132         DecoderError( p_pack->p_fifo );
133     }
134
135     EndThread( p_pack );
136
137     if( p_pack )
138     {
139         free( p_pack );
140     }
141
142     if( b_error )
143     {
144         return( -1 );
145     }
146
147     return( 0 );
148 }
149
150
151 /*****************************************************************************
152  * InitThread: initialize data before entering main loop
153  *****************************************************************************/
154
155 static int InitThread( packetizer_t *p_pack )
156 {
157
158     p_pack->output_format.i_cat = VIDEO_ES;
159     p_pack->output_format.i_fourcc = VLC_FOURCC( 'm', 'p', 'g', 'v');
160
161     p_pack->p_sout_input = NULL;
162
163     if( InitBitstream( &p_pack->bit_stream, p_pack->p_fifo,
164                        NULL, NULL ) != VLC_SUCCESS )
165     {
166         msg_Err( p_pack->p_fifo, "cannot initialize bitstream" );
167         return -1;
168     }
169
170     p_pack->i_last_picture_structure = 0x03; /* frame picture */
171     return( 0 );
172 }
173
174 /* from ISO 13818-2 */
175 /* converting frame_rate_code to frame_rate */
176 static const double pd_frame_rates[16] =
177 {
178     0, 24000/1001, 24, 25, 30000/1001, 30, 50, 60000/1001, 60,
179     0, 0, 0, 0, 0, 0, 0
180 };
181
182 static int CopyUntilNextStartCode( packetizer_t   *p_pack,
183                                    sout_buffer_t  *p_sout_buffer,
184                                    unsigned int   *pi_pos )
185 {
186     int i_copy = 0;
187
188     do
189     {
190         p_sout_buffer->p_buffer[(*pi_pos)++] =
191                 GetBits( &p_pack->bit_stream, 8 );
192         i_copy++;
193
194         if( *pi_pos + 2048 > p_sout_buffer->i_buffer_size )
195         {
196             sout_BufferRealloc( p_pack->p_sout_input->p_sout,
197                                 p_sout_buffer,
198                                 p_sout_buffer->i_buffer_size + 50 * 1024);
199         }
200
201     } while( ShowBits( &p_pack->bit_stream, 24 ) != 0x01 &&
202              !p_pack->p_fifo->b_die && !p_pack->p_fifo->b_error );
203
204     return( i_copy );
205 }
206
207 /*****************************************************************************
208  * PacketizeThread: packetize an unit (here copy a complete pes)
209  *****************************************************************************/
210 static void PacketizeThread( packetizer_t *p_pack )
211 {
212     sout_buffer_t *p_sout_buffer = NULL;
213     int32_t       i_pos;
214     int           i_skipped;
215     mtime_t       i_duration; /* of the parsed picture */
216
217     mtime_t       i_pts;
218     mtime_t       i_dts;
219
220     /* needed to calculate pts/dts */
221     int i_temporal_ref = 0;
222     int i_picture_structure = 0x03; /* frame picture */
223     int i_top_field_first = 0;
224     int i_repeat_first_field = 0;
225
226     if( !p_pack->p_sout_input )
227     {
228         byte_t p_temp[512];/* 150 bytes is the maximal size
229                                of a sequence_header + sequence_extension */
230         int i_frame_rate_code;
231         BITMAPINFOHEADER *p_bih;
232
233         p_bih = malloc( sizeof( BITMAPINFOHEADER ) );
234         p_pack->output_format.p_format = (void*)p_bih;
235
236         /* skip data until we find a sequence_header_code */
237         /* TODO: store skipped somewhere so can send it to the mux
238          * after the input is created */
239         i_skipped = 0;
240         while( ShowBits( &p_pack->bit_stream, 32 ) != 0x1B3 &&
241                !p_pack->p_fifo->b_die && !p_pack->p_fifo->b_error )
242         {
243             RemoveBits( &p_pack->bit_stream, 8 );
244             i_skipped++;
245         }
246         msg_Warn( p_pack->p_fifo, "sequence_header_code found (%d skipped)",
247                  i_skipped );
248
249         /* copy the start_code */
250         i_pos = 0;
251         GetChunk( &p_pack->bit_stream, p_temp, 4 ); i_pos += 4;
252
253         p_bih->biSize = sizeof( BITMAPINFOHEADER );
254         /* horizontal_size_value */
255         p_bih->biWidth = ShowBits( &p_pack->bit_stream, 12 );
256         /* vertical_size_value */
257         p_bih->biHeight = ShowBits( &p_pack->bit_stream, 24 ) & 0xFFF;
258         /* frame_rate_code */
259         i_frame_rate_code = ShowBits( &p_pack->bit_stream, 32 ) & 0xF;
260         p_bih->biPlanes = 1;
261         p_bih->biBitCount = 0;
262         p_bih->biCompression = VLC_FOURCC( 'm', 'p', 'g', '2' );
263         p_bih->biSizeImage = 0;
264         p_bih->biXPelsPerMeter = 0;
265         p_bih->biYPelsPerMeter = 0;
266         p_bih->biClrUsed = 0;
267         p_bih->biClrImportant = 0;
268
269         /* copy headers */
270         GetChunk( &p_pack->bit_stream, p_temp + i_pos, 7 ); i_pos += 7;
271
272         /* intra_quantiser_matrix [non_intra_quantiser_matrix] */
273         if( ShowBits( &p_pack->bit_stream, 7 ) & 0x1 )
274         {
275
276             GetChunk( &p_pack->bit_stream, p_temp + i_pos, 64 ); i_pos += 64;
277
278             if( ShowBits( &p_pack->bit_stream, 8 ) & 0x1 )
279             {
280                 GetChunk( &p_pack->bit_stream, p_temp + i_pos, 65); i_pos += 65;
281             }
282         }
283         /* non_intra_quantiser_matrix */
284         else if( ShowBits( &p_pack->bit_stream, 8 ) & 0x1 )
285         {
286             GetChunk( &p_pack->bit_stream, p_temp + i_pos, 65); i_pos += 65;
287         }
288         /* nothing */
289         else
290         {
291             GetChunk( &p_pack->bit_stream, p_temp + i_pos, 1 ); i_pos += 1;
292         }
293
294         /* sequence_extension (10 bytes) */
295         if( ShowBits( &p_pack->bit_stream, 32 ) != 0x1B5 )
296         {
297             msg_Dbg( p_pack->p_fifo, "ARRGG no extension_start_code" );
298             p_pack->i_progressive_sequence = 1;
299         }
300         else
301         {
302             GetChunk( &p_pack->bit_stream, p_temp + i_pos, 10 );
303             p_pack->i_progressive_sequence = ( p_temp[i_pos+5]&0x08 ) ? 1 : 0;
304
305             i_pos += 10;
306         }
307
308         /* remember sequence_header and sequence_extention */
309         memcpy( p_pack->p_sequence_header, p_temp, i_pos );
310         p_pack->i_sequence_header_length = i_pos;
311
312         p_pack->d_frame_rate =  pd_frame_rates[i_frame_rate_code];
313
314         msg_Warn( p_pack->p_fifo,
315                   "creating input (image size %dx%d, frame rate %.2f)",
316                   p_bih->biWidth, p_bih->biHeight, p_pack->d_frame_rate );
317
318         /* now we have informations to create the input */
319         p_pack->p_sout_input = sout_InputNew( p_pack->p_fifo,
320                                               &p_pack->output_format );
321
322         if( !p_pack->p_sout_input )
323         {
324             msg_Err( p_pack->p_fifo, "cannot add a new stream" );
325             p_pack->p_fifo->b_error = VLC_TRUE;
326             return;
327         }
328
329         p_sout_buffer = sout_BufferNew( p_pack->p_sout_input->p_sout,
330                                         100 * 1024 );
331         p_sout_buffer->i_size = i_pos;
332         memcpy( p_sout_buffer->p_buffer, p_temp, i_pos );
333
334     }
335     else
336     {
337         p_sout_buffer =
338                 sout_BufferNew( p_pack->p_sout_input->p_sout, 100 * 1024 );
339         i_pos = 0;
340     }
341
342     p_pack->i_last_sequence_header++;
343
344     for( ;; )
345     {
346         uint32_t i_code;
347         if( p_pack->p_fifo->b_die || p_pack->p_fifo->b_error )
348         {
349             break;
350         }
351
352         i_code = ShowBits( &p_pack->bit_stream, 32 );
353
354         if( i_code == 0x1B8 ) /* GOP */
355         {
356             /* usefull for bad MPEG-1 : repeat the sequence_header
357                every second */
358             if( p_pack->i_last_sequence_header > (int) p_pack->d_frame_rate )
359             {
360                memcpy( p_sout_buffer->p_buffer + i_pos,
361                        p_pack->p_sequence_header,
362                        p_pack->i_sequence_header_length );
363                i_pos += p_pack->i_sequence_header_length;
364                p_pack->i_last_sequence_header = 0;
365             }
366
367             p_pack->i_last_ref_pts =
368                    p_pack->i_last_dts + 40000; /* FIXME */
369             CopyUntilNextStartCode( p_pack, p_sout_buffer, &i_pos );
370         }
371         else if( i_code == 0x100 ) /* Picture */
372         {
373             /* picture_start_code */
374             GetChunk( &p_pack->bit_stream,
375                       p_sout_buffer->p_buffer + i_pos, 4 ); i_pos += 4;
376
377             NextPTS( &p_pack->bit_stream, &i_pts, &i_dts );
378             i_temporal_ref = ShowBits( &p_pack->bit_stream, 10 );
379
380             CopyUntilNextStartCode( p_pack, p_sout_buffer, &i_pos );
381             break;
382         }
383         else if( i_code == 0x1b5 )
384         {
385             /* extention start code                   32 */
386             GetChunk( &p_pack->bit_stream,
387                       p_sout_buffer->p_buffer + i_pos, 4 ); i_pos += 4;
388
389             if( ShowBits( &p_pack->bit_stream, 4 ) == 0x08 )
390             {
391                 /* picture coding extention */
392
393                 /* extention start code identifier(b1000)  4 */
394                 /* f_code[2][2]                           16 */
395                 /* intra_dc_precision                      2 */
396                 /* picture_structure                       2 */
397                 /* top_field_first                         1 */
398                 i_picture_structure =
399                     ShowBits( &p_pack->bit_stream, 24 ) & 0x03;
400                 i_top_field_first =
401                     ShowBits( &p_pack->bit_stream, 25 ) & 0x01;
402                 i_repeat_first_field =
403                     ShowBits( &p_pack->bit_stream, 31 ) & 0x01;
404             }
405             CopyUntilNextStartCode( p_pack, p_sout_buffer, &i_pos );
406         }
407         else
408         {
409             if( i_code == 0x1B3 )
410             {
411                 p_pack->i_last_sequence_header = 0;
412             }
413             CopyUntilNextStartCode( p_pack, p_sout_buffer, &i_pos );
414         }
415     }
416
417     sout_BufferRealloc( p_pack->p_sout_input->p_sout,
418                         p_sout_buffer, i_pos );
419     p_sout_buffer->i_size = i_pos;
420
421     /* calculate dts/pts */
422     if( p_pack->i_progressive_sequence || i_picture_structure == 0x03)
423     {
424         i_duration = (mtime_t)( 1000000 / p_pack->d_frame_rate );
425     }
426     else
427     {
428         i_duration = (mtime_t)( 1000000 / p_pack->d_frame_rate / 2);
429     }
430
431     /* fix i_last_dts and i_last_ref_pts with i_dts and i_pts from stream */
432     if( i_dts <= 0 && p_pack->i_last_dts <= 0 )
433     {
434         msg_Dbg( p_pack->p_fifo, "need a starting pts" );
435         sout_BufferDelete( p_pack->p_sout_input->p_sout,
436                            p_sout_buffer );
437         return;
438     }
439
440     if( i_dts > 0 )
441     {
442         p_pack->i_last_dts = i_dts;
443     }
444     if( i_pts > 0 )
445     {
446         p_pack->i_last_ref_pts =
447             i_pts - i_temporal_ref *
448                     (mtime_t)( 1000000 / p_pack->d_frame_rate );
449     }
450
451     p_sout_buffer->i_dts = p_pack->i_last_dts;
452     p_sout_buffer->i_pts = p_pack->i_last_ref_pts + 
453         i_temporal_ref * (mtime_t)( 1000000 / p_pack->d_frame_rate );
454     p_sout_buffer->i_length = i_duration;
455     p_sout_buffer->i_bitrate = (int)( 8 * i_pos * p_pack->d_frame_rate );
456     sout_InputSendBuffer( p_pack->p_sout_input, p_sout_buffer );
457
458     if( p_pack->i_progressive_sequence )
459     {
460         if( i_top_field_first == 0 && i_repeat_first_field == 0 )
461         {
462             p_pack->i_last_dts += i_duration;
463         }
464         else if( i_top_field_first == 0 && i_repeat_first_field == 1 )
465         {
466             p_pack->i_last_dts += 2 * i_duration;
467         }
468         else if( i_top_field_first == 1 && i_repeat_first_field == 1 )
469         {
470             p_pack->i_last_dts += 3 * i_duration;
471         }
472     }
473     else
474     {
475         if( i_picture_structure == 0x03 )
476         {
477             p_pack->i_last_dts += i_duration;
478         }
479         else if( i_picture_structure == p_pack->i_last_picture_structure )
480         {
481             p_pack->i_last_dts += 2 * i_duration;
482         }
483         else if( ( !i_top_field_first && i_picture_structure == 0x01 ) ||
484                  (  i_top_field_first && i_picture_structure == 0x02 ) )
485         {
486             p_pack->i_last_dts += 2 * i_duration;
487         }
488     }
489     p_pack->i_last_picture_structure = i_picture_structure;
490 }
491
492
493 /*****************************************************************************
494  * EndThread : packetizer thread destruction
495  *****************************************************************************/
496 static void EndThread ( packetizer_t *p_pack)
497 {
498     if( p_pack->p_sout_input )
499     {
500         sout_InputDelete( p_pack->p_sout_input );
501     }
502 }